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     return sink;
55 }
56 
HWTEST(TestSubtitleSink, do_sync_write_not_eos, TestSize.Level1)57 HWTEST(TestSubtitleSink, do_sync_write_not_eos, TestSize.Level1)
58 {
59     auto sink = SubtitleSinkCreate();
60     ASSERT_TRUE(sink != nullptr);
61     auto syncCenter = std::make_shared<MediaSyncManager>();
62     sink->SetSyncCenter(syncCenter);
63     sink->PrepareInputBufferQueue();
64     sink->Prepare();
65     sink->state_ = Pipeline::FilterState::READY;
66     auto bufferQP = sink->GetBufferQueueProducer();
67     ASSERT_TRUE(bufferQP != nullptr);
68     auto bufferQC = sink->GetBufferQueueConsumer();
69     ASSERT_TRUE(bufferQC != nullptr);
70     sink->subtitleInfoVec_.push_back({"test", 1, 1});
71     sink->isThreadExit_ = true;
72     sink->RenderLoop();
73 
74     AVBufferConfig config;
75     config.size = 4;
76     config.memoryType = MemoryType::SHARED_MEMORY;
77     std::shared_ptr<AVBuffer> buffer = nullptr;
78     auto ret = bufferQP->RequestBuffer(buffer, config, 1000);
79     ASSERT_TRUE(ret == Status::OK);
80     ASSERT_TRUE(buffer != nullptr && buffer->memory_ != nullptr);
81     auto addr = buffer->memory_->GetAddr();
82     char subtitle[] = "test";
83     memcpy_s(addr, 4, subtitle, 4);
84     ret = bufferQP->ReturnBuffer(buffer, true);
85 }
86 
HWTEST(TestSubtitleSink, do_sync_write_two_frames_case1, TestSize.Level1)87 HWTEST(TestSubtitleSink, do_sync_write_two_frames_case1, TestSize.Level1)
88 {
89     auto sink = SubtitleSinkCreate();
90     ASSERT_TRUE(sink != nullptr);
91     auto syncCenter = std::make_shared<MediaSyncManager>();
92     sink->SetSyncCenter(syncCenter);
93     sink->Prepare();
94     sink->subtitleInfoVec_.push_back({"test", 1, 1});
95     SubtitleSink::SubtitleInfo tempSubtitleInfo = {{"test", 1, 1}};
96     sink->NotifyRender(tempSubtitleInfo);
97     sink->isThreadExit_ = true;
98     sink->CalcWaitTime(tempSubtitleInfo);
99     sink->ActionToDo(tempSubtitleInfo);
100     sink->RenderLoop();
101 
102     AVBufferConfig config;
103     config.size = 4;
104     config.memoryType = MemoryType::SHARED_MEMORY;
105     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
106     buffer->flag_ = 0; // not eos
107     sink->DoSyncWrite(buffer);
108     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
109     buffer->flag_ = 0; // not eos
110     sink->DoSyncWrite(buffer2);
111     sink->SetSpeed(2.0F);
112     sink->Flush();
113     sink->Pause();
114     sink->NotifySeek();
115     sink->Resume();
116     sink->Stop();
117     sink->Release();
118     EXPECT_EQ(sink->Release(), Status::OK);
119 }
120 
HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case2, TestSize.Level1)121 HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case2, TestSize.Level1)
122 {
123     auto sink = SubtitleSinkCreate();
124     ASSERT_TRUE(sink != nullptr);
125     auto syncCenter = std::make_shared<MediaSyncManager>();
126     sink->SetSyncCenter(syncCenter);
127     sink->PrepareInputBufferQueue();
128     sink->PrepareInputBufferQueue();
129     sink->Prepare();
130     sink->subtitleInfoVec_.push_back({"test", 1, 1});
131     sink->shouldUpdate_ = true;
132     SubtitleSink::SubtitleInfo tempSubtitleInfo = {{"test", 1, 1}};
133     std::shared_ptr<EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
134     sink->SetEventReceiver(testEventReceiver);
135     sink->NotifyRender(tempSubtitleInfo);
136     sink->isThreadExit_ = true;
137     sink->RenderLoop();
138     sink->isEos_ = false;
139     sink->filledOutputBuffer_ = std::make_shared<AVBuffer>();
140     sink->filledOutputBuffer_->flag_ = 1;
141     sink->filledOutputBuffer_->memory_= std::make_shared<AVMemory>();
142     sink->DrainOutputBuffer(true);
143 
144     AVBufferConfig config;
145     config.size = 4;
146     config.memoryType = MemoryType::SHARED_MEMORY;
147     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
148     buffer->flag_ = 0; // not eos
149     sink->DoSyncWrite(buffer);
150     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
151     buffer->flag_ = 0; // not eos
152     sink->DoSyncWrite(buffer2);
153     sink->SetSpeed(2.0F);
154     sink->Flush();
155     sink->Pause();
156     sink->NotifySeek();
157     sink->Resume();
158     sink->Stop();
159     sink->Release();
160     EXPECT_EQ(sink->Release(), Status::OK);
161 }
162 
HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case3, TestSize.Level1)163 HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case3, TestSize.Level1)
164 {
165     auto sink = SubtitleSinkCreate();
166     ASSERT_TRUE(sink != nullptr);
167     auto syncCenter = std::make_shared<MediaSyncManager>();
168     sink->SetSyncCenter(syncCenter);
169     sink->PrepareInputBufferQueue();
170     sink->PrepareInputBufferQueue();
171     sink->Prepare();
172     sink->subtitleInfoVec_.push_back({"test", 1, 1});
173     sink->isThreadExit_ = true;
174     sink->shouldUpdate_ = false;
175     sink->RenderLoop();
176     sink->filledOutputBuffer_ = std::make_shared<AVBuffer>();
177     sink->filledOutputBuffer_->flag_ = 1;
178     sink->filledOutputBuffer_->memory_= std::make_shared<AVMemory>();
179     sink->DrainOutputBuffer(true);
180 
181     AVBufferConfig config;
182     config.size = 4;
183     config.memoryType = MemoryType::SHARED_MEMORY;
184     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
185     buffer->flag_ = 0; // not eos
186     sink->DoSyncWrite(buffer);
187     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
188     buffer->flag_ = 0; // not eos
189     sink->DoSyncWrite(buffer2);
190     sink->SetSpeed(2.0F);
191     sink->Flush();
192     sink->Pause();
193     sink->NotifySeek();
194     sink->Resume();
195     sink->Stop();
196     sink->Release();
197     EXPECT_EQ(sink->Release(), Status::OK);
198 }
199 
HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case4, TestSize.Level1)200 HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case4, TestSize.Level1)
201 {
202     auto sink = SubtitleSinkCreate();
203     ASSERT_TRUE(sink != nullptr);
204     auto syncCenter = std::make_shared<MediaSyncManager>();
205     sink->SetSyncCenter(syncCenter);
206     sink->PrepareInputBufferQueue();
207     sink->PrepareInputBufferQueue();
208     sink->Prepare();
209     sink->subtitleInfoVec_.push_back({"test", 1, 1});
210     sink->subtitleInfoVec_.push_back({"test", 1, 1});
211     sink->isThreadExit_ = true;
212     sink->RenderLoop();
213     sink->filledOutputBuffer_ = std::make_shared<AVBuffer>();
214     sink->filledOutputBuffer_->flag_ = 1;
215     sink->filledOutputBuffer_->memory_= std::make_shared<AVMemory>();
216     sink->DrainOutputBuffer(true);
217 
218     AVBufferConfig config;
219     config.size = 4;
220     config.memoryType = MemoryType::SHARED_MEMORY;
221     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
222     buffer->flag_ = 0; // not eos
223     sink->DoSyncWrite(buffer);
224     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
225     buffer->flag_ = 0; // not eos
226     sink->DoSyncWrite(buffer2);
227     sink->SetSpeed(2.0F);
228     sink->Flush();
229     sink->Pause();
230     sink->NotifySeek();
231     sink->Resume();
232     sink->Stop();
233     sink->Release();
234     EXPECT_EQ(sink->Release(), Status::OK);
235 }
236 
HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case5, TestSize.Level1)237 HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case5, TestSize.Level1)
238 {
239     auto sink = SubtitleSinkCreate();
240     ASSERT_TRUE(sink != nullptr);
241     auto syncCenter = std::make_shared<MediaSyncManager>();
242     sink->SetSyncCenter(syncCenter);
243     sink->PrepareInputBufferQueue();
244     sink->PrepareInputBufferQueue();
245     sink->Prepare();
246     sink->subtitleInfoVec_.push_back({"test", 1, 1});
247     sink->subtitleInfoVec_.push_back({"test", 2, 1});
248     sink->isThreadExit_ = true;
249     sink->RenderLoop();
250     sink->filledOutputBuffer_ = std::make_shared<AVBuffer>();
251     sink->filledOutputBuffer_->flag_ = 1;
252     sink->filledOutputBuffer_->memory_= std::make_shared<AVMemory>();
253     sink->DrainOutputBuffer(true);
254 
255     AVBufferConfig config;
256     config.size = 4;
257     config.memoryType = MemoryType::SHARED_MEMORY;
258     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
259     buffer->flag_ = 0; // not eos
260     sink->DoSyncWrite(buffer);
261     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
262     buffer->flag_ = 0; // not eos
263     sink->DoSyncWrite(buffer2);
264     sink->SetSpeed(2.0F);
265     sink->Flush();
266     sink->Pause();
267     sink->NotifySeek();
268     sink->Resume();
269     sink->Stop();
270     sink->Release();
271     EXPECT_EQ(sink->Release(), Status::OK);
272 }
273 
HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case6, TestSize.Level1)274 HWTEST(TestSubtitleSink, do_sync_write_prepare_two_frames_case6, TestSize.Level1)
275 {
276     auto sink = SubtitleSinkCreate();
277     ASSERT_TRUE(sink != nullptr);
278     auto syncCenter = std::make_shared<MediaSyncManager>();
279     sink->SetSyncCenter(syncCenter);
280     sink->PrepareInputBufferQueue();
281     sink->PrepareInputBufferQueue();
282     sink->Prepare();
283     sink->isThreadExit_ = true;
284     sink->RenderLoop();
285     sink->filledOutputBuffer_ = std::make_shared<AVBuffer>();
286     sink->filledOutputBuffer_->flag_ = 1;
287     sink->filledOutputBuffer_->memory_= std::make_shared<AVMemory>();
288     sink->DrainOutputBuffer(true);
289 
290     AVBufferConfig config;
291     config.size = 4;
292     config.memoryType = MemoryType::SHARED_MEMORY;
293     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
294     buffer->flag_ = 0; // not eos
295     sink->DoSyncWrite(buffer);
296     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
297     buffer->flag_ = 0; // not eos
298     sink->DoSyncWrite(buffer2);
299     sink->SetSpeed(2.0F);
300     sink->Flush();
301     sink->Pause();
302     sink->NotifySeek();
303     sink->Resume();
304     sink->Stop();
305     sink->Release();
306     EXPECT_EQ(sink->Release(), Status::OK);
307 }
308 
HWTEST(TestSubtitleSink, do_sync_write_two_frames_case7, TestSize.Level1)309 HWTEST(TestSubtitleSink, do_sync_write_two_frames_case7, TestSize.Level1)
310 {
311     auto sink = SubtitleSinkCreate();
312     ASSERT_TRUE(sink != nullptr);
313     auto syncCenter = std::make_shared<MediaSyncManager>();
314     sink->SetSyncCenter(syncCenter);
315     sink->Prepare();
316     sink->subtitleInfoVec_.push_back({"test", 1, 1});
317     SubtitleSink::SubtitleInfo tempSubtitleInfo = {{"test", 1, 1}};
318     sink->NotifyRender(tempSubtitleInfo);
319     sink->isThreadExit_ = true;
320     sink->CalcWaitTime(tempSubtitleInfo);
321     sink->ActionToDo(tempSubtitleInfo);
322     sink->RenderLoop();
323 
324     AVBufferConfig config;
325     config.size = 4;
326     config.memoryType = MemoryType::SHARED_MEMORY;
327     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
328     buffer->flag_ = 0; // not eos
329     sink->DoSyncWrite(buffer);
330     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
331     buffer->flag_ = 0; // not eos
332     sink->DoSyncWrite(buffer2);
333     sink->SetSpeed(2.0F);
334     sink->Flush();
335     sink->Pause();
336     sink->NotifySeek();
337     sink->Resume();
338     sink->Stop();
339     sink->Release();
340     EXPECT_EQ(sink->Release(), Status::OK);
341 }
342 
HWTEST(TestSubtitleSink, do_sync_write_two_frames_case8, TestSize.Level1)343 HWTEST(TestSubtitleSink, do_sync_write_two_frames_case8, TestSize.Level1)
344 {
345     auto sink = SubtitleSinkCreate();
346     ASSERT_TRUE(sink != nullptr);
347     auto syncCenter = std::make_shared<MediaSyncManager>();
348     sink->SetSyncCenter(syncCenter);
349     sink->Prepare();
350     sink->subtitleInfoVec_.push_back({"test", 1, 1});
351     SubtitleSink::SubtitleInfo tempSubtitleInfo = {{"test", 2, 2}};
352     sink->NotifyRender(tempSubtitleInfo);
353 
354     sink->CalcWaitTime(tempSubtitleInfo);
355     sink->ActionToDo(tempSubtitleInfo);
356     sink->isThreadExit_ = true;
357     sink->RenderLoop();
358 
359     AVBufferConfig config;
360     config.size = 4;
361     config.memoryType = MemoryType::SHARED_MEMORY;
362     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
363     buffer->flag_ = 0; // not eos
364     sink->DoSyncWrite(buffer);
365     const std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
366     buffer->flag_ = 0; // not eos
367     sink->DoSyncWrite(buffer2);
368     sink->SetSpeed(2.0F);
369     sink->Flush();
370     sink->Pause();
371     sink->NotifySeek();
372     sink->Resume();
373     sink->Stop();
374     sink->Release();
375     EXPECT_EQ(sink->Release(), Status::OK);
376 }
377 
HWTEST(TestSubtitleSink, do_sync_write_eos, TestSize.Level1)378 HWTEST(TestSubtitleSink, do_sync_write_eos, TestSize.Level1)
379 {
380     auto sink = SubtitleSinkCreate();
381     ASSERT_TRUE(sink != nullptr);
382     auto syncCenter = std::make_shared<MediaSyncManager>();
383     sink->SetSyncCenter(syncCenter);
384     AVBufferConfig config;
385     config.size = 4;
386     config.memoryType = MemoryType::SHARED_MEMORY;
387     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
388     buffer->flag_ = 1; // eos
389     sink->DoSyncWrite(buffer);
390     sink->DoSyncWrite(buffer);
391     buffer->flag_ = BUFFER_FLAG_EOS;
392     sink->DoSyncWrite(buffer);
393     ASSERT_TRUE(sink->DoSyncWrite(buffer) != -1);
394 }
395 }  // namespace Test
396 }  // namespace Media
397 }  // namespace OHOS