1 /*
2 * Copyright (C) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17 #include "filter/filter.h"
18 #include "subtitle_sink.h"
19 #include "sink/media_synchronous_sink.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Media {
25 namespace Test {
26 using namespace Pipeline;
27
28 class TestEventReceiver : public EventReceiver {
29 public:
TestEventReceiver()30 explicit TestEventReceiver()
31 {
32 }
33
OnEvent(const Event & event)34 void OnEvent(const Event &event)
35 {
36 (void)event;
37 }
38
39 private:
40 };
41
SubtitleSinkCreate()42 std::shared_ptr<SubtitleSink> SubtitleSinkCreate()
43 {
44 auto sink = std::make_shared<SubtitleSink>();
45 auto meta = std::make_shared<Meta>();
46 std::shared_ptr<EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
47 sink->Init(meta, testEventReceiver);
48 sink->SetParameter(meta);
49 sink->GetParameter(meta);
50 sink->SetIsTransitent(false);
51 sink->SetEventReceiver(testEventReceiver);
52 sink->DrainOutputBuffer(false);
53 sink->ResetSyncInfo();
54 auto syncCenter = std::make_shared<MediaSyncManager>();
55 sink->SetSyncCenter(syncCenter);
56 return sink;
57 }
58
59 HWTEST(TestSubtitleSink, do_sync_write_not_eos, TestSize.Level1)
60 {
61 auto sink = SubtitleSinkCreate();
62 ASSERT_TRUE(sink != nullptr);
63 sink->Prepare();
64 auto bufferQP = sink->GetBufferQueueProducer();
65 ASSERT_TRUE(bufferQP != nullptr);
66 auto bufferQC = sink->GetBufferQueueConsumer();
67 ASSERT_TRUE(bufferQC != nullptr);
68 sink->Start();
69 AVBufferConfig config;
70 config.size = 4;
71 config.memoryType = MemoryType::SHARED_MEMORY;
72 std::shared_ptr<AVBuffer> buffer = nullptr;
73 auto ret = bufferQP->RequestBuffer(buffer, config, 1000);
74 ASSERT_TRUE(ret == Status::OK);
75 ASSERT_TRUE(buffer != nullptr && buffer->memory_ != nullptr);
76 auto addr = buffer->memory_->GetAddr();
77 char subtitle[] = "test";
78 memcpy_s(addr, 4, subtitle, 4);
79 ret = bufferQP->ReturnBuffer(buffer, true);
80 }
81
82 HWTEST(TestSubtitleSink, do_sync_write_two_frames, TestSize.Level1)
83 {
84 auto sink = SubtitleSinkCreate();
85 ASSERT_TRUE(sink != nullptr);
86
87 sink->Prepare();
88 sink->Start();
89
90 AVBufferConfig config;
91 config.size = 4;
92 config.memoryType = MemoryType::SHARED_MEMORY;
93 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
94 buffer->flag_ = 0; // not eos
95 sink->DoSyncWrite(buffer);
96 const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
97 buffer->flag_ = 0; // not eos
98 sink->DoSyncWrite(buffer2);
99 sink->SetSpeed(2.0F);
100 sink->Flush();
101 sink->Pause();
102 sink->NotifySeek();
103 sink->Resume();
104 sink->Stop();
105 sink->Release();
106 }
107
108 HWTEST(TestSubtitleSink, do_sync_write_eos, TestSize.Level1)
109 {
110 auto sink = SubtitleSinkCreate();
111 ASSERT_TRUE(sink != nullptr);
112 AVBufferConfig config;
113 config.size = 4;
114 config.memoryType = MemoryType::SHARED_MEMORY;
115 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
116 buffer->flag_ = 1; // eos
117 sink->DoSyncWrite(buffer);
118 sink->DoSyncWrite(buffer);
119 buffer->flag_ = BUFFER_FLAG_EOS;
120 sink->DoSyncWrite(buffer);
121 }
122 } // namespace Test
123 } // namespace Media
124 } // namespace OHOS