1 /*
2 * Copyright (C) 2023 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 <string>
17 #include <malloc.h>
18 #include <sys/stat.h>
19 #include <cinttypes>
20 #include <fcntl.h>
21 #include <list>
22 #include <cmath>
23 #include "gtest/gtest.h"
24 #include "avcodec_errors.h"
25 #include "media_description.h"
26 #include "file_server_demo.h"
27 #include "demuxer_unit_test.h"
28
29 #define LOCAL true
30
31 using namespace OHOS;
32 using namespace OHOS::Media;
33 using namespace OHOS::MediaAVCodec;
34 using namespace testing::ext;
35 using namespace std;
36
37 namespace {
38 unique_ptr<FileServerDemo> server = nullptr;
39 static const string TEST_FILE_PATH = "/data/test/media/";
40 static const string TEST_URI_PATH = "http://127.0.0.1:46666/";
41 int32_t g_width = 3840;
42 int32_t g_height = 2160;
43 list<SeekMode> seekModes = {SeekMode::SEEK_NEXT_SYNC, SeekMode::SEEK_PREVIOUS_SYNC,
44 SeekMode::SEEK_CLOSEST_SYNC};
45
46 string g_mp4Path = TEST_FILE_PATH + string("test_264_B_Gop25_4sec_cover.mp4");
47 string g_mp4Path2 = TEST_FILE_PATH + string("test_mpeg2_B_Gop25_4sec.mp4");
48 string g_mp4Path4 = TEST_FILE_PATH + string("zero_track.mp4");
49 string g_mp4Path5 = TEST_FILE_PATH + string("timed_metadata_track.mp4");
50 string g_mkvPath2 = TEST_FILE_PATH + string("h264_opus_4sec.mkv");
51 string g_tsPath = TEST_FILE_PATH + string("test_mpeg2_Gop25_4sec.ts");
52 string g_aacPath = TEST_FILE_PATH + string("audio/aac_44100_1.aac");
53 string g_flacPath = TEST_FILE_PATH + string("audio/flac_48000_1_cover.flac");
54 string g_m4aPath = TEST_FILE_PATH + string("audio/m4a_48000_1.m4a");
55 string g_mp3Path = TEST_FILE_PATH + string("audio/mp3_48000_1_cover.mp3");
56 string g_oggPath = TEST_FILE_PATH + string("audio/ogg_48000_1.ogg");
57 string g_wavPath = TEST_FILE_PATH + string("audio/wav_48000_1.wav");
58 string g_amrPath = TEST_FILE_PATH + string("audio/amr_nb_8000_1.amr");
59 string g_amrPath2 = TEST_FILE_PATH + string("audio/amr_wb_16000_1.amr");
60 string g_audioVividPath = TEST_FILE_PATH + string("2obj_44100Hz_16bit_32k.mp4");
61 string g_audioVividPath2 = TEST_FILE_PATH + string("2obj_44100Hz_16bit_32k.ts");
62 string g_multiSoundTrackMp4Path = TEST_FILE_PATH + string("avcc_aac_mp3.mp4");
63 string g_flvPath = TEST_FILE_PATH + string("h264.flv");
64 string g_apePath = TEST_FILE_PATH + string("ape_test.ape");
65 string g_fmp4AvcPath = TEST_FILE_PATH + string("h264_fmp4.mp4");
66 string g_fmp4m4vPath = TEST_FILE_PATH + string("h264_fmp4.m4v");
67 string g_fmp4m4aPath = TEST_FILE_PATH + string("audio/h264_fmp4.m4a");
68 string g_srt = TEST_FILE_PATH + string("subtitle.srt");
69 string g_drmSm4cPath = TEST_FILE_PATH + string("drm/sm4c.ts");
70 string g_vttPath = TEST_FILE_PATH + string("webvtt_test.vtt");
71 string g_vttPath2 = TEST_FILE_PATH + string("webvtt_test2.vtt");
72 string g_ptsConversionPath = TEST_FILE_PATH + string("camera_info_parser.mp4");
73 string g_mp4VvcPath = TEST_FILE_PATH + string("vvc.mp4");
74 } // namespace
75
SetUpTestCase(void)76 void DemuxerUnitTest::SetUpTestCase(void)
77 {
78 server = make_unique<FileServerDemo>();
79 server->StartServer();
80 cout << "start" << endl;
81 }
82
TearDownTestCase(void)83 void DemuxerUnitTest::TearDownTestCase(void)
84 {
85 server->StopServer();
86 }
87
SetUp(void)88 void DemuxerUnitTest::SetUp(void)
89 {
90 bufferSize_ = g_width * g_height;
91 }
92
TearDown(void)93 void DemuxerUnitTest::TearDown(void)
94 {
95 if (source_ != nullptr) {
96 source_->Destroy();
97 source_ = nullptr;
98 }
99 if (demuxer_ != nullptr) {
100 demuxer_->Destroy();
101 demuxer_ = nullptr;
102 }
103 if (format_ != nullptr) {
104 format_->Destroy();
105 format_ = nullptr;
106 }
107 if (sharedMem_ != nullptr) {
108 sharedMem_->Destory();
109 sharedMem_ = nullptr;
110 }
111 if (fd_ > 0) {
112 close(fd_);
113 fd_ = -1;
114 }
115 bufferSize_ = 0;
116 nbStreams_ = 0;
117 numbers_ = 0;
118 ret_ = AV_ERR_OK;
119 info_.presentationTimeUs = 0;
120 info_.offset = 0;
121 info_.size = 0;
122 initStatus_ = false;
123 selectedTrackIds_.clear();
124 }
125
GetFileSize(const string & fileName)126 int64_t DemuxerUnitTest::GetFileSize(const string &fileName)
127 {
128 int64_t fileSize = 0;
129 if (!fileName.empty()) {
130 struct stat fileStatus {};
131 if (stat(fileName.c_str(), &fileStatus) == 0) {
132 fileSize = static_cast<int64_t>(fileStatus.st_size);
133 }
134 }
135 return fileSize;
136 }
137
OpenFile(const string & fileName)138 int32_t DemuxerUnitTest::OpenFile(const string &fileName)
139 {
140 int32_t fd = open(fileName.c_str(), O_RDONLY);
141 return fd;
142 }
143
isEOS(map<uint32_t,bool> & countFlag)144 bool DemuxerUnitTest::isEOS(map<uint32_t, bool>& countFlag)
145 {
146 for (auto iter = countFlag.begin(); iter != countFlag.end(); ++iter) {
147 if (!iter->second) {
148 return false;
149 }
150 }
151 return true;
152 }
153
SetInitValue()154 void DemuxerUnitTest::SetInitValue()
155 {
156 for (int i = 0; i < nbStreams_; i++) {
157 string codecMime = "";
158 int32_t trackType = -1;
159 if (format_ != nullptr) {
160 format_->Destroy();
161 format_ = nullptr;
162 }
163 format_ = source_->GetTrackFormat(i);
164 format_->GetStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, codecMime);
165 format_->GetIntValue(MediaDescriptionKey::MD_KEY_TRACK_TYPE, trackType);
166 if (codecMime.find("image/") != std::string::npos) {
167 continue;
168 }
169 if (trackType == MediaType::MEDIA_TYPE_VID || trackType == MediaType::MEDIA_TYPE_AUD ||
170 trackType == MediaType::MEDIA_TYPE_SUBTITLE || trackType == MediaType::MEDIA_TYPE_TIMED_METADATA) {
171 selectedTrackIds_.push_back(static_cast<uint32_t>(i));
172 frames_[i] = 0;
173 keyFrames_[i] = 0;
174 eosFlag_[i] = false;
175 }
176 }
177 }
178
RemoveValue()179 void DemuxerUnitTest::RemoveValue()
180 {
181 if (!frames_.empty()) {
182 frames_.clear();
183 }
184 if (!keyFrames_.empty()) {
185 keyFrames_.clear();
186 }
187 if (!eosFlag_.empty()) {
188 eosFlag_.clear();
189 }
190 }
191
SetEosValue()192 void DemuxerUnitTest::SetEosValue()
193 {
194 for (int i = 0; i < nbStreams_; i++) {
195 eosFlag_[i] = true;
196 }
197 }
198
CountFrames(uint32_t index)199 void DemuxerUnitTest::CountFrames(uint32_t index)
200 {
201 if (flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS) {
202 eosFlag_[index] = true;
203 return;
204 }
205
206 if (flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_SYNC_FRAME) {
207 keyFrames_[index]++;
208 frames_[index]++;
209 } else if ((flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE) == AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE) {
210 frames_[index]++;
211 } else {
212 SetEosValue();
213 printf("flag is unknown, read sample break");
214 }
215 }
216
ReadData()217 void DemuxerUnitTest::ReadData()
218 {
219 SetInitValue();
220 while (!isEOS(eosFlag_)) {
221 for (auto idx : selectedTrackIds_) {
222 demuxer_->ReadSample(idx, sharedMem_, &info_, flag_);
223 if (ret_ != AV_ERR_OK) {
224 break;
225 }
226 CountFrames(idx);
227 }
228 if (ret_ != AV_ERR_OK) {
229 break;
230 }
231 }
232 }
233
ReadData(int readNum,int64_t & seekTime)234 void DemuxerUnitTest::ReadData(int readNum, int64_t &seekTime)
235 {
236 int num = 0;
237 SetInitValue();
238 while (!isEOS(eosFlag_)) {
239 for (auto idx : selectedTrackIds_) {
240 ret_ = demuxer_->ReadSample(idx, sharedMem_, &info_, flag_);
241 if (ret_ != AV_ERR_OK) {
242 break;
243 }
244 CountFrames(idx);
245 }
246 if (ret_ != AV_ERR_OK) {
247 break;
248 }
249 if (num == readNum) {
250 seekTime = info_.presentationTimeUs;
251 break;
252 }
253 }
254 }
255
256 /**********************************demuxer fd**************************************/
257 namespace {
258 /**
259 * @tc.name: Demuxer_CreateDemuxer_1000
260 * @tc.desc: create demuxer
261 * @tc.type: FUNC
262 */
263 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_1000, TestSize.Level1)
264 {
265 InitResource(g_mp4Path, LOCAL);
266 ASSERT_TRUE(initStatus_);
267 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
268 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
269 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
270 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
271 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
272 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
273 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
274 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
275 }
276
277 /**
278 * @tc.name: Demuxer_CreateDemuxer_1010
279 * @tc.desc: create demuxer
280 * @tc.type: FUNC
281 */
282 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_1010, TestSize.Level1)
283 {
284 source_ = nullptr;
285 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_);
286 ASSERT_EQ(demuxer_, nullptr);
287 demuxer_ = nullptr;
288 }
289
290 /**
291 * @tc.name: Demuxer_CreateDemuxer_1020
292 * @tc.desc: repeatedly create demuxer
293 * @tc.type: FUNC
294 */
295 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_1020, TestSize.Level1)
296 {
297 InitResource(g_mp4Path, LOCAL);
298 ASSERT_TRUE(initStatus_);
299 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_);
300 ASSERT_NE(demuxer_, nullptr);
301 }
302
303 /**
304 * @tc.name: Demuxer_CreateDemuxer_1030
305 * @tc.desc: create demuxer
306 * @tc.type: FUNC
307 */
308 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_1030, TestSize.Level1)
309 {
310 InitResource(g_tsPath, LOCAL);
311 ASSERT_TRUE(initStatus_);
312 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
313 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
314 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
315 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
316 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
317 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
318 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
319 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
320 }
321
322 /**
323 * @tc.name: Demuxer_CreateDemuxer_1040
324 * @tc.desc: create demuxer
325 * @tc.type: FUNC
326 */
327 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_1040, TestSize.Level1)
328 {
329 InitResource(g_mp4Path4, LOCAL);
330 }
331
332 /**
333 * @tc.name: Demuxer_UnselectTrackByID_1000
334 * @tc.desc: select and remove track by ID
335 * @tc.type: FUNC
336 */
337 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1000, TestSize.Level1)
338 {
339 InitResource(g_mp4Path4, LOCAL);
340 ASSERT_TRUE(initStatus_);
341 ASSERT_NE(demuxer_->SelectTrackByID(0), AV_ERR_OK);
342 }
343
344 /**
345 * @tc.name: Demuxer_UnselectTrackByID_1010
346 * @tc.desc: select and remove track by ID
347 * @tc.type: FUNC
348 */
349 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1010, TestSize.Level1)
350 {
351 InitResource(g_aacPath, LOCAL);
352 ASSERT_TRUE(initStatus_);
353 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
354 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
355 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
356 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
357 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
358 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
359 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
360 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
361 }
362
363 /**
364 * @tc.name: Demuxer_UnselectTrackByID_1020
365 * @tc.desc: select and remove track by ID
366 * @tc.type: FUNC
367 */
368 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1020, TestSize.Level1)
369 {
370 InitResource(g_flacPath, LOCAL);
371 ASSERT_TRUE(initStatus_);
372 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
373 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
374 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
375 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
376 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
377 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
378 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
379 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
380 }
381
382 /**
383 * @tc.name: Demuxer_UnselectTrackByID_1030
384 * @tc.desc: select and remove track by ID
385 * @tc.type: FUNC
386 */
387 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1030, TestSize.Level1)
388 {
389 InitResource(g_m4aPath, LOCAL);
390 ASSERT_TRUE(initStatus_);
391 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
392 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
393 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
394 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
395 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
396 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
397 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
398 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
399 }
400
401 /**
402 * @tc.name: Demuxer_UnselectTrackByID_1060
403 * @tc.desc: select and remove track by ID
404 * @tc.type: FUNC
405 */
406 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1060, TestSize.Level1)
407 {
408 InitResource(g_mp3Path, LOCAL);
409 ASSERT_TRUE(initStatus_);
410 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
411 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
412 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
413 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
414 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
415 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
416 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
417 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
418 }
419
420 /**
421 * @tc.name: Demuxer_UnselectTrackByID_1070
422 * @tc.desc: select and remove track by ID
423 * @tc.type: FUNC
424 */
425 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1070, TestSize.Level1)
426 {
427 InitResource(g_oggPath, LOCAL);
428 ASSERT_TRUE(initStatus_);
429 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
430 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
431 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
432 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
433 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
434 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
435 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
436 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
437 }
438
439 /**
440 * @tc.name: Demuxer_UnselectTrackByID_1080
441 * @tc.desc: select and remove track by ID
442 * @tc.type: FUNC
443 */
444 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1080, TestSize.Level1)
445 {
446 InitResource(g_wavPath, LOCAL);
447 ASSERT_TRUE(initStatus_);
448 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
449 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
450 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
451 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
452 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
453 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
454 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
455 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
456 }
457
458 /**
459 * @tc.name: Demuxer_UnselectTrackByID_1090
460 * @tc.desc: select and remove track by ID
461 * @tc.type: FUNC
462 */
463 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1090, TestSize.Level1)
464 {
465 InitResource(g_mkvPath2, LOCAL);
466 ASSERT_TRUE(initStatus_);
467 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
468 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
469 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
470 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
471 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
472 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
473 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
474 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
475 }
476
477 /**
478 * @tc.name: Demuxer_UnselectTrackByID_1100
479 * @tc.desc: select and remove track by ID
480 * @tc.type: FUNC
481 */
482 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_1100, TestSize.Level1)
483 {
484 InitResource(g_amrPath, LOCAL);
485 ASSERT_TRUE(initStatus_);
486 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
487 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
488 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
489 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
490 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
491 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK);
492 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
493 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
494 }
495
496 /**
497 * @tc.name: Demuxer_ReadSample_1000
498 * @tc.desc: copy current sample to buffer
499 * @tc.type: FUNC
500 */
501 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1000, TestSize.Level1)
502 {
503 InitResource(g_mp4Path, LOCAL);
504 ASSERT_TRUE(initStatus_);
505 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
506 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
507 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
508 ASSERT_NE(sharedMem_, nullptr);
509 SetInitValue();
510 while (!isEOS(eosFlag_)) {
511 for (auto idx : selectedTrackIds_) {
512 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
513 CountFrames(idx);
514 }
515 }
516 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
517 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
518 ASSERT_EQ(frames_[0], 103);
519 ASSERT_EQ(frames_[1], 174);
520 ASSERT_EQ(keyFrames_[0], 5);
521 ASSERT_EQ(keyFrames_[1], 174);
522 RemoveValue();
523 }
524
525 /**
526 * @tc.name: Demuxer_ReadSample_1050
527 * @tc.desc: Read sample test for timed metadata track
528 * @tc.type: FUNC
529 */
530 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1050, TestSize.Level1)
531 {
532 InitResource(g_mp4Path5, LOCAL);
533 ASSERT_TRUE(initStatus_);
534 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
535 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
536 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
537 ASSERT_NE(sharedMem_, nullptr);
538 SetInitValue();
539 while (!isEOS(eosFlag_)) {
540 for (auto idx : selectedTrackIds_) {
541 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
542 CountFrames(idx);
543 }
544 }
545 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
546 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
547 ASSERT_EQ(frames_[0], 601);
548 ASSERT_EQ(frames_[1], 601);
549 ASSERT_EQ(keyFrames_[0], 3);
550 ASSERT_EQ(keyFrames_[1], 601);
551 RemoveValue();
552 }
553
554 /**
555 * @tc.name: Demuxer_ReadSample_1010
556 * @tc.desc: copy current sample to buffer
557 * @tc.type: FUNC
558 */
559 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1010, TestSize.Level1)
560 {
561 InitResource(g_mp4Path, LOCAL);
562 ASSERT_TRUE(initStatus_);
563 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
564 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
565 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
566 ASSERT_NE(sharedMem_, nullptr);
567 uint32_t idx = 4;
568 ASSERT_NE(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
569 }
570
571 /**
572 * @tc.name: Demuxer_ReadSample_1020
573 * @tc.desc: copy current sample to buffer
574 * @tc.type: FUNC
575 */
576 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1020, TestSize.Level1)
577 {
578 InitResource(g_mp4Path, LOCAL);
579 ASSERT_TRUE(initStatus_);
580 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
581 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
582 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
583 ASSERT_NE(sharedMem_, nullptr);
584 uint32_t idx = -1;
585 ASSERT_NE(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
586 }
587
588 /**
589 * @tc.name: Demuxer_ReadSample_1030
590 * @tc.desc: copy current sample to buffer(only video track)
591 * @tc.type: FUNC
592 */
593 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1030, TestSize.Level1)
594 {
595 InitResource(g_mp4Path, LOCAL);
596 ASSERT_TRUE(initStatus_);
597 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
598 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
599 ASSERT_NE(sharedMem_, nullptr);
600 int32_t vkeyFrames = 0;
601 int32_t vframes = 0;
602 flag_ = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE;
603 while (!(flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS)) {
604 ASSERT_EQ(demuxer_->ReadSample(0, sharedMem_, &info_, flag_), AV_ERR_OK);
605 if (flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS) {
606 break;
607 }
608 if (flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_SYNC_FRAME) {
609 vkeyFrames++;
610 vframes++;
611 } else if ((flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE) == 0) {
612 vframes++;
613 }
614 }
615 printf("vframes=%d | vkFrames=%d\n", vframes, vkeyFrames);
616 ASSERT_EQ(vframes, 103);
617 ASSERT_EQ(vkeyFrames, 5);
618 }
619
620 /**
621 * @tc.name: Demuxer_ReadSample_1040
622 * @tc.desc: copy current sample to buffer
623 * @tc.type: FUNC
624 */
625 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1040, TestSize.Level1)
626 {
627 InitResource(g_mp4Path2, LOCAL);
628 ASSERT_TRUE(initStatus_);
629 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
630 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
631 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
632 ASSERT_NE(sharedMem_, nullptr);
633 SetInitValue();
634 while (!isEOS(eosFlag_)) {
635 for (auto idx : selectedTrackIds_) {
636 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
637 CountFrames(idx);
638 }
639 }
640 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
641 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
642 ASSERT_EQ(frames_[0], 103);
643 ASSERT_EQ(frames_[1], 174);
644 ASSERT_EQ(keyFrames_[0], 5);
645 ASSERT_EQ(keyFrames_[1], 174);
646 RemoveValue();
647 }
648
649 /**
650 * @tc.name: Demuxer_ReadSample_1070
651 * @tc.desc: copy current sample to buffer
652 * @tc.type: FUNC
653 */
654 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1070, TestSize.Level1)
655 {
656 InitResource(g_mkvPath2, LOCAL);
657 ASSERT_TRUE(initStatus_);
658 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
659 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
660 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
661 ASSERT_NE(sharedMem_, nullptr);
662 SetInitValue();
663 while (!isEOS(eosFlag_)) {
664 for (auto idx : selectedTrackIds_) {
665 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
666 CountFrames(idx);
667 }
668 }
669 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
670 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
671 ASSERT_EQ(frames_[0], 240);
672 ASSERT_EQ(frames_[1], 199);
673 ASSERT_EQ(keyFrames_[0], 4);
674 ASSERT_EQ(keyFrames_[1], 199);
675 RemoveValue();
676 }
677
678 /**
679 * @tc.name: Demuxer_ReadSample_1090
680 * @tc.desc: copy current sample to buffer
681 * @tc.type: FUNC
682 */
683 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1090, TestSize.Level1)
684 {
685 InitResource(g_tsPath, LOCAL);
686 ASSERT_TRUE(initStatus_);
687 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
688 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
689 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
690 ASSERT_NE(sharedMem_, nullptr);
691 SetInitValue();
692 while (!isEOS(eosFlag_)) {
693 for (auto idx : selectedTrackIds_) {
694 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
695 CountFrames(idx);
696 }
697 }
698 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
699 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
700 ASSERT_EQ(frames_[0], 103);
701 ASSERT_EQ(frames_[1], 174);
702 ASSERT_EQ(keyFrames_[0], 5);
703 ASSERT_EQ(keyFrames_[1], 174);
704 RemoveValue();
705 }
706
707 /**
708 * @tc.name: Demuxer_ReadSample_1100
709 * @tc.desc: copy current sample to buffer
710 * @tc.type: FUNC
711 */
712 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1100, TestSize.Level1)
713 {
714 InitResource(g_aacPath, LOCAL);
715 ASSERT_TRUE(initStatus_);
716 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
717 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
718 ASSERT_NE(sharedMem_, nullptr);
719 SetInitValue();
720 uint32_t idx = 0;
721 while (!isEOS(eosFlag_)) {
722 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
723 CountFrames(idx);
724 }
725 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
726 ASSERT_EQ(frames_[0], 1293);
727 ASSERT_EQ(keyFrames_[0], 1293);
728 RemoveValue();
729 }
730
731 /**
732 * @tc.name: Demuxer_ReadSample_1110
733 * @tc.desc: copy current sample to buffer
734 * @tc.type: FUNC
735 */
736 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1110, TestSize.Level1)
737 {
738 InitResource(g_flacPath, LOCAL);
739 ASSERT_TRUE(initStatus_);
740 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
741 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
742 ASSERT_NE(sharedMem_, nullptr);
743 SetInitValue();
744 uint32_t idx = 0;
745 while (!isEOS(eosFlag_)) {
746 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
747 CountFrames(idx);
748 }
749 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
750 ASSERT_EQ(frames_[0], 313);
751 ASSERT_EQ(keyFrames_[0], 313);
752 RemoveValue();
753 }
754
755 /**
756 * @tc.name: Demuxer_ReadSample_1120
757 * @tc.desc: copy current sample to buffer
758 * @tc.type: FUNC
759 */
760 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1120, TestSize.Level1)
761 {
762 InitResource(g_m4aPath, LOCAL);
763 ASSERT_TRUE(initStatus_);
764 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
765 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
766 ASSERT_NE(sharedMem_, nullptr);
767 SetInitValue();
768 uint32_t idx = 0;
769 while (!isEOS(eosFlag_)) {
770 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
771 CountFrames(idx);
772 }
773 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
774 ASSERT_EQ(frames_[0], 1408);
775 ASSERT_EQ(keyFrames_[0], 1408);
776 RemoveValue();
777 }
778
779 /**
780 * @tc.name: Demuxer_ReadSample_1130
781 * @tc.desc: copy current sample to buffer
782 * @tc.type: FUNC
783 */
784 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1130, TestSize.Level1)
785 {
786 InitResource(g_mp3Path, LOCAL);
787 ASSERT_TRUE(initStatus_);
788 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
789 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
790 ASSERT_NE(sharedMem_, nullptr);
791 SetInitValue();
792 uint32_t idx = 0;
793 while (!isEOS(eosFlag_)) {
794 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
795 CountFrames(idx);
796 }
797 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
798 ASSERT_EQ(frames_[0], 1251);
799 ASSERT_EQ(keyFrames_[0], 1251);
800 RemoveValue();
801 }
802
803 /**
804 * @tc.name: Demuxer_ReadSample_1140
805 * @tc.desc: copy current sample to buffer
806 * @tc.type: FUNC
807 */
808 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1140, TestSize.Level1)
809 {
810 InitResource(g_oggPath, LOCAL);
811 ASSERT_TRUE(initStatus_);
812 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
813 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
814 ASSERT_NE(sharedMem_, nullptr);
815 SetInitValue();
816 uint32_t idx = 0;
817 while (!isEOS(eosFlag_)) {
818 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
819 CountFrames(idx);
820 }
821 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
822 ASSERT_EQ(frames_[0], 1598);
823 ASSERT_EQ(keyFrames_[0], 1598);
824 RemoveValue();
825 }
826
827 /**
828 * @tc.name: Demuxer_ReadSample_1150
829 * @tc.desc: copy current sample to buffer
830 * @tc.type: FUNC
831 */
832 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1150, TestSize.Level1)
833 {
834 InitResource(g_wavPath, LOCAL);
835 ASSERT_TRUE(initStatus_);
836 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
837 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
838 ASSERT_NE(sharedMem_, nullptr);
839 SetInitValue();
840 uint32_t idx = 0;
841 while (!isEOS(eosFlag_)) {
842 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
843 CountFrames(idx);
844 }
845 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
846 ASSERT_EQ(frames_[0], 704);
847 ASSERT_EQ(keyFrames_[0], 704);
848 RemoveValue();
849 }
850
851 /**
852 * @tc.name: Demuxer_ReadSample_1160
853 * @tc.desc: copy current sample to buffer
854 * @tc.type: FUNC
855 */
856 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1160, TestSize.Level1)
857 {
858 InitResource(g_amrPath, LOCAL);
859 ASSERT_TRUE(initStatus_);
860 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
861 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
862 ASSERT_NE(sharedMem_, nullptr);
863 SetInitValue();
864 uint32_t idx = 0;
865 while (!isEOS(eosFlag_)) {
866 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
867 CountFrames(idx);
868 }
869 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
870 ASSERT_EQ(frames_[0], 1501);
871 ASSERT_EQ(keyFrames_[0], 1501);
872 RemoveValue();
873 }
874
875 /**
876 * @tc.name: Demuxer_ReadSample_1170
877 * @tc.desc: copy current sample to buffer
878 * @tc.type: FUNC
879 */
880 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1170, TestSize.Level1)
881 {
882 InitResource(g_amrPath2, LOCAL);
883 ASSERT_TRUE(initStatus_);
884 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
885 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
886 ASSERT_NE(sharedMem_, nullptr);
887 SetInitValue();
888 uint32_t idx = 0;
889 while (!isEOS(eosFlag_)) {
890 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
891 CountFrames(idx);
892 }
893 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
894 ASSERT_EQ(frames_[0], 1500);
895 ASSERT_EQ(keyFrames_[0], 1500);
896 RemoveValue();
897 }
898
899 /**
900 * @tc.name: Demuxer_ReadSample_1180
901 * @tc.desc: copy current sample to buffer(av3a mp4)
902 * @tc.type: FUNC
903 */
904 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1180, TestSize.Level1)
905 {
906 InitResource(g_audioVividPath, LOCAL);
907 ASSERT_TRUE(initStatus_);
908 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
909 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
910 ASSERT_NE(sharedMem_, nullptr);
911 SetInitValue();
912 uint32_t idx = 0;
913 while (!isEOS(eosFlag_)) {
914 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
915 CountFrames(idx);
916 }
917 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
918 ASSERT_EQ(frames_[0], 1380);
919 ASSERT_EQ(keyFrames_[0], 1380);
920 RemoveValue();
921 }
922
923
924 /**
925 * @tc.name: Demuxer_SeekToTime_1000
926 * @tc.desc: seek to the specified time
927 * @tc.type: FUNC
928 */
929 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1000, TestSize.Level1)
930 {
931 InitResource(g_mp4Path, LOCAL);
932 ASSERT_TRUE(initStatus_);
933 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
934 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
935 list<int64_t> toPtsList = {0, 2000, 1920, 2160, 2200, 2440, 2600, 2700, 4080, 4100}; // ms
936 vector<int32_t> audioVals = {174, 174, 174, 90, 91, 91, 90, 134, 90, 47, 91, 91, 47, 91, 91, 47, 91, 47, 47, 91, 47,
937 47, 91, 47, 5, 5, 5, 5};
938 vector<int32_t> videoVals = {103, 103, 103, 53, 53, 53, 53, 78, 53, 28, 53, 53, 28, 53, 53, 28, 53, 28, 28, 53, 28,
939 28, 53, 28, 3, 3, 3, 3};
940 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
941 ASSERT_NE(sharedMem_, nullptr);
942 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
943 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
944 ret_ = demuxer_->SeekToTime(*toPts, *mode);
945 if (ret_ != AV_ERR_OK) {
946 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
947 continue;
948 }
949 ReadData();
950 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
951 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]);
952 ASSERT_EQ(frames_[0], videoVals[numbers_]);
953 ASSERT_EQ(frames_[1], audioVals[numbers_]);
954 numbers_ += 1;
955 RemoveValue();
956 selectedTrackIds_.clear();
957 }
958 }
959 }
960
961 /**
962 * @tc.name: Demuxer_SeekToTime_1001
963 * @tc.desc: seek to the specified time
964 * @tc.type: FUNC
965 */
966 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1001, TestSize.Level1)
967 {
968 InitResource(g_mp4Path, LOCAL);
969 ASSERT_TRUE(initStatus_);
970 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
971 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
972 list<int64_t> toPtsList = {-100, 1000000}; // ms
973 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
974 ASSERT_NE(sharedMem_, nullptr);
975 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
976 ret_ = demuxer_->SeekToTime(*toPts, SeekMode::SEEK_NEXT_SYNC);
977 ASSERT_NE(ret_, AV_ERR_OK);
978 ret_ = demuxer_->SeekToTime(*toPts, SeekMode::SEEK_PREVIOUS_SYNC);
979 ASSERT_NE(ret_, AV_ERR_OK);
980 ret_ = demuxer_->SeekToTime(*toPts, SeekMode::SEEK_CLOSEST_SYNC);
981 ASSERT_NE(ret_, AV_ERR_OK);
982 }
983 }
984
985 /**
986 * @tc.name: Demuxer_SeekToTime_1002
987 * @tc.desc: seek to the specified time
988 * @tc.type: FUNC
989 */
990 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1002, TestSize.Level1)
991 {
992 InitResource(g_mp4Path, LOCAL);
993 ASSERT_TRUE(initStatus_);
994 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
995 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
996 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
997 ASSERT_NE(sharedMem_, nullptr);
998 int readNum = 121;
999 int64_t seekTime = 0;
1000 ReadData(readNum, seekTime);
1001 seekTime = (seekTime / 1000) + 500;
1002 ASSERT_EQ(demuxer_->SeekToTime(seekTime, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1003 ASSERT_EQ(demuxer_->ReadSample(0, sharedMem_, &info_, flag_), AV_ERR_OK);
1004 printf("time = %" PRId64 " | pts = %" PRId64 "\n", seekTime, info_.presentationTimeUs);
1005 }
1006
1007 /**
1008 * @tc.name: Demuxer_SeekToTime_1010
1009 * @tc.desc: seek to the specified time
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1010, TestSize.Level1)
1013 {
1014 InitResource(g_mp4Path2, LOCAL);
1015 ASSERT_TRUE(initStatus_);
1016 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1017 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1018 list<int64_t> toPtsList = {0, 3000, 2040, 1880, 1960, 2400, 2720, 2830, 4040, 4100}; // ms
1019 vector<int32_t> audioVals = {174, 174, 174, 7, 49, 49, 48, 91, 91, 90, 132, 90, 90, 91, 91, 48, 91, 91, 48, 91, 48,
1020 48, 91, 48, 8, 8, 8, 8};
1021 vector<int32_t> videoVals = {103, 103, 103, 6, 30, 30, 30, 54, 54, 54, 78, 54, 54, 54, 54, 30, 54, 54, 30, 54, 30,
1022 30, 54, 30, 6, 6, 6, 6};
1023 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1024 ASSERT_NE(sharedMem_, nullptr);
1025 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1026 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1027 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1028 if (ret_ != AV_ERR_OK) {
1029 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1030 continue;
1031 }
1032 ReadData();
1033 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1034 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]);
1035 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1036 ASSERT_EQ(frames_[1], audioVals[numbers_]);
1037 numbers_ += 1;
1038 RemoveValue();
1039 selectedTrackIds_.clear();
1040 }
1041 }
1042 }
1043
1044 /**
1045 * @tc.name: Demuxer_SeekToTime_1040
1046 * @tc.desc: seek to the specified time
1047 * @tc.type: FUNC
1048 */
1049 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1040, TestSize.Level1)
1050 {
1051 InitResource(g_mkvPath2, LOCAL);
1052 ASSERT_TRUE(initStatus_);
1053 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1054 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1055 list<int64_t> toPtsList = {0, 1000, 1017, 1500, 1700, 1940, 3983, 1983, 3990}; // ms
1056 vector<int32_t> audioVals = {199, 199, 199, 149, 149, 149, 99, 149, 149, 99, 149, 149, 99, 149, 99, 99, 149, 99,
1057 49, 49, 99, 149, 99, 49, 49};
1058 vector<int32_t> videoVals = {240, 240, 240, 180, 180, 180, 120, 180, 180, 120, 180, 180, 120, 180, 120, 120, 180,
1059 120, 60, 60, 120, 180, 120, 60, 60};
1060 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1061 ASSERT_NE(sharedMem_, nullptr);
1062 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1063 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1064 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1065 if (ret_ != AV_ERR_OK) {
1066 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1067 continue;
1068 }
1069 ReadData();
1070 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1071 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]);
1072 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1073 ASSERT_EQ(frames_[1], audioVals[numbers_]);
1074 numbers_ += 1;
1075 RemoveValue();
1076 selectedTrackIds_.clear();
1077 }
1078 }
1079 }
1080
1081 /**
1082 * @tc.name: Demuxer_SeekToTime_1060
1083 * @tc.desc: seek to the specified time
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1060, TestSize.Level1)
1087 {
1088 InitResource(g_tsPath, LOCAL);
1089 ASSERT_TRUE(initStatus_);
1090 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1091 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1092 list<int64_t> toPtsList = {0, 3480, 3640, 3320, 3000, 3100, 4120, 5520}; // ms
1093 vector<int32_t> videoVals = {102, 102, 102, 15, 15, 15, 11, 11, 11, 19, 19, 19, 27, 27, 27, 24, 25, 25, 1, 1, 1};
1094 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1095 ASSERT_NE(sharedMem_, nullptr);
1096 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1097 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1098 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1099 if (ret_ != AV_ERR_OK) {
1100 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1101 continue;
1102 }
1103 ReadData();
1104 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1105 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1106 numbers_ += 1;
1107 RemoveValue();
1108 selectedTrackIds_.clear();
1109 }
1110 }
1111 }
1112
1113 /**
1114 * @tc.name: Demuxer_SeekToTime_1070
1115 * @tc.desc: seek to the specified time
1116 * @tc.type: FUNC
1117 */
1118 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1070, TestSize.Level1)
1119 {
1120 InitResource(g_aacPath, LOCAL);
1121 ASSERT_TRUE(initStatus_);
1122 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1123 list<int64_t> toPtsList = {0, 10240, 10230, 10220, 30000, 30010}; // ms
1124 vector<int32_t> audioVals = {1293, 1293, 1293, 852, 852, 852, 853, 853, 853, 853, 853, 853, 2, 2, 2, 1, 1, 1};
1125 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1126 ASSERT_NE(sharedMem_, nullptr);
1127 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1128 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1129 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1130 if (ret_ != AV_ERR_OK) {
1131 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1132 continue;
1133 }
1134 ReadData();
1135 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1136 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1137 numbers_ += 1;
1138 RemoveValue();
1139 selectedTrackIds_.clear();
1140 }
1141 }
1142 }
1143
1144 /**
1145 * @tc.name: Demuxer_SeekToTime_1080
1146 * @tc.desc: seek to the specified time
1147 * @tc.type: FUNC
1148 */
1149 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1080, TestSize.Level1)
1150 {
1151 InitResource(g_flacPath, LOCAL);
1152 ASSERT_TRUE(initStatus_);
1153 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1154 list<int64_t> toPtsList = {0, 3072, 4031, 4035, 29952, 29953}; // ms
1155 vector<int32_t> audioVals = {313, 313, 313, 281, 281, 281, 272, 272, 272, 271, 271, 271, 1, 1, 1, 2, 2, 2};
1156 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1157 ASSERT_NE(sharedMem_, nullptr);
1158 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1159 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1160 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1161 if (ret_ != AV_ERR_OK) {
1162 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1163 continue;
1164 }
1165 ReadData();
1166 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1167 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1168 numbers_ += 1;
1169 RemoveValue();
1170 selectedTrackIds_.clear();
1171 }
1172 }
1173 }
1174
1175 /**
1176 * @tc.name: Demuxer_SeekToTime_1090
1177 * @tc.desc: seek to the specified time
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1090, TestSize.Level1)
1181 {
1182 InitResource(g_m4aPath, LOCAL);
1183 ASSERT_TRUE(initStatus_);
1184 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1185 list<int64_t> toPtsList = {0, 14592, 15297, 15290, 29994, 29998}; // ms
1186 vector<int32_t> audioVals = {1407, 1407, 1407, 723, 723, 723, 690, 690, 690, 691, 691, 691, 2, 2, 2, 1, 1, 1};
1187 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1188 ASSERT_NE(sharedMem_, nullptr);
1189 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1190 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1191 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1192 if (ret_ != AV_ERR_OK) {
1193 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1194 continue;
1195 }
1196 ReadData();
1197 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1198 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1199 numbers_ += 1;
1200 RemoveValue();
1201 selectedTrackIds_.clear();
1202 }
1203 }
1204 }
1205
1206 /**
1207 * @tc.name: Demuxer_SeekToTime_1100
1208 * @tc.desc: seek to the specified time
1209 * @tc.type: FUNC
1210 */
1211 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1100, TestSize.Level1)
1212 {
1213 InitResource(g_mp3Path, LOCAL);
1214 ASSERT_TRUE(initStatus_);
1215 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1216 list<int64_t> toPtsList = {0, 4128, 11980, 11990, 30000, 30010}; // ms
1217 vector<int32_t> audioVals = {1251, 1251, 1251, 1079, 1079, 1079, 752, 752, 752, 752, 752, 752, 1, 1, 1, 1, 1, 1};
1218 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1219 ASSERT_NE(sharedMem_, nullptr);
1220 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1221 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1222 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1223 if (ret_ != AV_ERR_OK) {
1224 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1225 continue;
1226 }
1227 ReadData();
1228 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1229 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1230 numbers_ += 1;
1231 RemoveValue();
1232 selectedTrackIds_.clear();
1233 }
1234 }
1235 }
1236
1237 /**
1238 * @tc.name: Demuxer_SeekToTime_1110
1239 * @tc.desc: seek to the specified time
1240 * @tc.type: FUNC
1241 */
1242 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1110, TestSize.Level1)
1243 {
1244 InitResource(g_oggPath, LOCAL);
1245 ASSERT_TRUE(initStatus_);
1246 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1247 list<int64_t> toPtsList = {0, 5868, 5548, 5292, 29992, 29999}; // ms
1248 vector<int32_t> audioVals = {1598, 1598, 1598, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 46, 46,
1249 46, 46, 46, 46};
1250 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1251 ASSERT_NE(sharedMem_, nullptr);
1252 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1253 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1254 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1255 if (ret_ != AV_ERR_OK) {
1256 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1257 continue;
1258 }
1259 ReadData();
1260 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1261 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1262 numbers_ += 1;
1263 RemoveValue();
1264 selectedTrackIds_.clear();
1265 }
1266 }
1267 }
1268
1269 /**
1270 * @tc.name: Demuxer_SeekToTime_1120
1271 * @tc.desc: seek to the specified time
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1120, TestSize.Level1)
1275 {
1276 InitResource(g_wavPath, LOCAL);
1277 ASSERT_TRUE(initStatus_);
1278 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1279 list<int64_t> toPtsList = {0, 8576, 8566, 8578, 29994, 30000}; // ms
1280 vector<int32_t> audioVals = {704, 704, 704, 503, 503, 503, 504, 504, 504, 503, 503, 503, 2, 2, 2, 1, 1, 1};
1281 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1282 ASSERT_NE(sharedMem_, nullptr);
1283 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1284 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1285 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1286 if (ret_ != AV_ERR_OK) {
1287 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1288 continue;
1289 }
1290 ReadData();
1291 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1292 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1293 numbers_ += 1;
1294 RemoveValue();
1295 selectedTrackIds_.clear();
1296 }
1297 }
1298 }
1299
1300 /**
1301 * @tc.name: Demuxer_SeekToTime_1130
1302 * @tc.desc: seek to the specified time
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1130, TestSize.Level1)
1306 {
1307 InitResource(g_amrPath, LOCAL);
1308 ASSERT_TRUE(initStatus_);
1309 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1310 list<int64_t> toPtsList = {0, 8560, 8550, 8570, 30000, 30900}; // ms
1311 vector<int32_t> audioVals = {1501, 1501, 1501, 1073, 1073, 1073, 1074, 1074, 1074, 1073, 1073, 1073,
1312 1, 1, 1, 1, 1, 1};
1313 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1314 ASSERT_NE(sharedMem_, nullptr);
1315 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1316 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1317 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1318 if (ret_ != AV_ERR_OK) {
1319 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1320 continue;
1321 }
1322 ReadData();
1323 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1324 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1325 numbers_ += 1;
1326 RemoveValue();
1327 selectedTrackIds_.clear();
1328 }
1329 }
1330 }
1331
1332 /**
1333 * @tc.name: Demuxer_SeekToTime_1140
1334 * @tc.desc: seek to the specified time
1335 * @tc.type: FUNC
1336 */
1337 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1140, TestSize.Level1)
1338 {
1339 InitResource(g_amrPath2, LOCAL);
1340 ASSERT_TRUE(initStatus_);
1341 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1342 list<int64_t> toPtsList = {0, 11920, 11910, 11930, 29980, 30800}; // ms
1343 vector<int32_t> audioVals = {1500, 1500, 1500, 904, 904, 904, 905, 905, 905, 904, 904, 904,
1344 1, 1, 1, 1, 1, 1};
1345 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1346 ASSERT_NE(sharedMem_, nullptr);
1347 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1348 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1349 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1350 if (ret_ != AV_ERR_OK) {
1351 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1352 continue;
1353 }
1354 ReadData();
1355 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1356 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1357 numbers_ += 1;
1358 RemoveValue();
1359 selectedTrackIds_.clear();
1360 }
1361 }
1362 }
1363
1364 /**
1365 * @tc.name: Demuxer_SeekToTime_1150
1366 * @tc.desc: seek to the specified time(audioVivid mp4)
1367 * @tc.type: FUNC
1368 */
1369 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1150, TestSize.Level1)
1370 {
1371 InitResource(g_audioVividPath, LOCAL);
1372 ASSERT_TRUE(initStatus_);
1373 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1374 list<int64_t> toPtsList = {0, 10000, 8000, 12300, 25000, 29000, 30800, 33000}; // ms
1375 vector<int32_t> audioVals = {1380, 1380, 1380, 950, 950, 950, 1036, 1036, 1036, 851, 851, 851, 304, 304, 304,
1376 132, 132, 132, 54, 54, 54};
1377 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1378 ASSERT_NE(sharedMem_, nullptr);
1379 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1380 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1381 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1382 if (ret_ != AV_ERR_OK) {
1383 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1384 continue;
1385 }
1386 ReadData();
1387 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1388 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1389 numbers_ += 1;
1390 RemoveValue();
1391 selectedTrackIds_.clear();
1392 }
1393 }
1394 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
1395 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
1396 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
1397 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
1398 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
1399 }
1400
1401 /**
1402 * @tc.name: Demuxer_SeekToTime_1160
1403 * @tc.desc: seek to the specified time(audioVivid ts)
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1160, TestSize.Level1)
1407 {
1408 InitResource(g_audioVividPath2, LOCAL);
1409 ASSERT_TRUE(initStatus_);
1410 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1411 list<int64_t> toPtsList = {0, 10000, 8000, 12300, 25000, 29000, 30800, 32000}; // ms
1412 vector<int32_t> audioVals = {92, 92, 92, 68, 68, 68, 74, 74, 74, 61, 61, 61, 25, 25, 25, 13, 13, 13, 8, 8, 8};
1413 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1414 ASSERT_NE(sharedMem_, nullptr);
1415 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1416 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1417 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1418 if (ret_ != AV_ERR_OK) {
1419 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1420 continue;
1421 }
1422 ReadData();
1423 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1424 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1425 numbers_ += 1;
1426 RemoveValue();
1427 selectedTrackIds_.clear();
1428 }
1429 }
1430 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK);
1431 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK);
1432 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK);
1433 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK);
1434 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK);
1435 }
1436
1437 /**
1438 * @tc.name: Demuxer_SeekToTime_1200
1439 * @tc.desc: read first and then seek
1440 * @tc.type: FUNC
1441 */
1442 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1200, TestSize.Level1)
1443 {
1444 InitResource(g_mp4Path2, LOCAL);
1445 ASSERT_TRUE(initStatus_);
1446 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1447 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1448 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1449 ASSERT_NE(sharedMem_, nullptr);
1450 SetInitValue();
1451 for (int i = 0; i < 50; i++) {
1452 for (auto idx : selectedTrackIds_) {
1453 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1454 }
1455 }
1456 int64_t seekTime = info_.presentationTimeUs / 1000 + 2000;
1457 ASSERT_EQ(demuxer_->SeekToTime(seekTime, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1458 ASSERT_EQ(demuxer_->ReadSample(0, sharedMem_, &info_, flag_), AV_ERR_OK);
1459 ASSERT_EQ(info_.presentationTimeUs, 3960000);
1460 RemoveValue();
1461 }
1462
1463 /**
1464 * @tc.name: Demuxer_ReadSample_1219
1465 * @tc.desc: copy current sample to buffer(two sound track mp4)
1466 * @tc.type: FUNC
1467 */
1468 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1219, TestSize.Level1)
1469 {
1470 InitResource(g_multiSoundTrackMp4Path, LOCAL);
1471 ASSERT_TRUE(initStatus_);
1472 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1473 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1474 ASSERT_EQ(demuxer_->SelectTrackByID(2), AV_ERR_OK);
1475 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1476 ASSERT_NE(sharedMem_, nullptr);
1477 SetInitValue();
1478 while (!isEOS(eosFlag_)) {
1479 for (auto idx : selectedTrackIds_) {
1480 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1481 CountFrames(idx);
1482 }
1483 }
1484 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1485 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
1486 printf("frames_[2]=%d | kFrames[2]=%d\n", frames_[2], keyFrames_[2]);
1487 ASSERT_EQ(frames_[0], 602);
1488 ASSERT_EQ(frames_[1], 433);
1489 ASSERT_EQ(frames_[2], 417);
1490 ASSERT_EQ(keyFrames_[0], 3);
1491 ASSERT_EQ(keyFrames_[1], 433);
1492 ASSERT_EQ(keyFrames_[2], 417);
1493 RemoveValue();
1494 }
1495
1496 /**
1497 * @tc.name: Demuxer_ReadSample_1228
1498 * @tc.desc: copy current sample to buffer, local
1499 * @tc.type: FUNC
1500 */
1501 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1228, TestSize.Level1)
1502 {
1503 InitResource(g_fmp4AvcPath, LOCAL);
1504 ASSERT_TRUE(initStatus_);
1505 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1506 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1507 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1508 ASSERT_NE(sharedMem_, nullptr);
1509 SetInitValue();
1510 while (!isEOS(eosFlag_)) {
1511 for (auto idx : selectedTrackIds_) {
1512 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1513 CountFrames(idx);
1514 }
1515 }
1516 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1517 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
1518 ASSERT_EQ(frames_[0], 602);
1519 ASSERT_EQ(frames_[1], 433);
1520 ASSERT_EQ(keyFrames_[0], 3);
1521 ASSERT_EQ(keyFrames_[1], 433);
1522 RemoveValue();
1523 }
1524
1525 /**
1526 * @tc.name: Demuxer_ReadSample_1234
1527 * @tc.desc: copy current sample to buffer, local
1528 * @tc.type: FUNC
1529 */
1530 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1234, TestSize.Level1)
1531 {
1532 InitResource(g_fmp4m4vPath, LOCAL);
1533 ASSERT_TRUE(initStatus_);
1534 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1535 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1536 ASSERT_NE(sharedMem_, nullptr);
1537 SetInitValue();
1538 while (!isEOS(eosFlag_)) {
1539 for (auto idx : selectedTrackIds_) {
1540 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1541 CountFrames(idx);
1542 }
1543 }
1544 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1545 ASSERT_EQ(frames_[0], 602);
1546 ASSERT_EQ(keyFrames_[0], 3);
1547 RemoveValue();
1548 }
1549
1550 /**
1551 * @tc.name: Demuxer_ReadSample_1236
1552 * @tc.desc: copy current sample to buffer, local
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1236, TestSize.Level1)
1556 {
1557 InitResource(g_fmp4m4aPath, LOCAL);
1558 ASSERT_TRUE(initStatus_);
1559 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1560 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1561 ASSERT_NE(sharedMem_, nullptr);
1562 SetInitValue();
1563 while (!isEOS(eosFlag_)) {
1564 for (auto idx : selectedTrackIds_) {
1565 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1566 CountFrames(idx);
1567 }
1568 }
1569 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1570 ASSERT_EQ(frames_[0], 433);
1571 ASSERT_EQ(keyFrames_[0], 433);
1572 RemoveValue();
1573 }
1574
1575 /**
1576 * @tc.name: Demuxer_SeekToTime_1194
1577 * @tc.desc: seek to the specified time(two sound track mp4 local)
1578 * @tc.type: FUNC
1579 */
1580 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1194, TestSize.Level1)
1581 {
1582 InitResource(g_multiSoundTrackMp4Path, LOCAL);
1583 ASSERT_TRUE(initStatus_);
1584 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1585 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1586 ASSERT_EQ(demuxer_->SelectTrackByID(2), AV_ERR_OK);
1587 list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000}; // ms
1588 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602, 102, 102};
1589 vector<int32_t> audioVals = {433, 433, 433, 74, 254, 254, 74, 254, 74, 253, 433, 433, 75, 75};
1590 vector<int32_t> audioVals2 = {417, 417, 417, 71, 245, 245, 71, 245, 71, 244, 417, 417, 72, 72};
1591 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1592 ASSERT_NE(sharedMem_, nullptr);
1593 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1594 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1595 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1596 if (ret_ != AV_ERR_OK) {
1597 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1598 continue;
1599 }
1600 ReadData();
1601 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1602 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]);
1603 printf("time = %" PRId64 " | frames_[2]=%d | kFrames[2]=%d\n", *toPts, frames_[2], keyFrames_[2]);
1604 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1605 ASSERT_EQ(frames_[1], audioVals[numbers_]);
1606 ASSERT_EQ(frames_[2], audioVals2[numbers_]);
1607 numbers_ += 1;
1608 RemoveValue();
1609 selectedTrackIds_.clear();
1610 }
1611 }
1612 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1613 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1614 }
1615
1616 /**
1617 * @tc.name: Demuxer_ReadSample_1222
1618 * @tc.desc: copy current sample to buffer(ape)
1619 * @tc.type: FUNC
1620 */
1621 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1222, TestSize.Level1)
1622 {
1623 InitResource(g_apePath, LOCAL);
1624 ASSERT_TRUE(initStatus_);
1625 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1626 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1627 ASSERT_NE(sharedMem_, nullptr);
1628 SetInitValue();
1629 uint32_t idx = 0;
1630 while (!isEOS(eosFlag_)) {
1631 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1632 CountFrames(idx);
1633 }
1634 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1635 ASSERT_EQ(frames_[0], 7);
1636 ASSERT_EQ(keyFrames_[0], 7);
1637 RemoveValue();
1638 }
1639
1640 /**
1641 * @tc.name: Demuxer_SeekToTime_1224
1642 * @tc.desc: seek to the specified time(two sound track ape local)
1643 * @tc.type: FUNC
1644 */
1645 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1224, TestSize.Level1)
1646 {
1647 InitResource(g_apePath, LOCAL);
1648 ASSERT_TRUE(initStatus_);
1649 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1650 list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000}; // ms
1651 vector<int32_t> audioVals = {7, 7, 7, 5, 5, 5, 3, 3, 3, 6, 6, 6, 2, 2, 2};
1652
1653 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1654 ASSERT_NE(sharedMem_, nullptr);
1655 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1656 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1657 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1658 if (ret_ != AV_ERR_OK) {
1659 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1660 continue;
1661 }
1662 ReadData();
1663 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]);
1664 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1665 numbers_ += 1;
1666 RemoveValue();
1667 selectedTrackIds_.clear();
1668 }
1669 }
1670 ASSERT_NE(demuxer_->SeekToTime(12000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1671 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1672 }
1673
1674 /**
1675 * @tc.name: Demuxer_ReadSample_1400
1676 * @tc.desc: copy current sample to buffer(flv)
1677 * @tc.type: FUNC
1678 */
1679 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1400, TestSize.Level1)
1680 {
1681 InitResource(g_flvPath, LOCAL);
1682 ASSERT_TRUE(initStatus_);
1683 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1684 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK);
1685 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1686 ASSERT_NE(sharedMem_, nullptr);
1687 SetInitValue();
1688 while (!isEOS(eosFlag_)) {
1689 for (auto idx : selectedTrackIds_) {
1690 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1691 CountFrames(idx);
1692 }
1693 }
1694 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1695 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
1696 ASSERT_EQ(frames_[0], 76);
1697 ASSERT_EQ(frames_[1], 113);
1698 ASSERT_EQ(keyFrames_[0], 1);
1699 ASSERT_EQ(keyFrames_[1], 113);
1700 RemoveValue();
1701 }
1702
1703 /**
1704 * @tc.name: Demuxer_SeekToTime_1206
1705 * @tc.desc: seek to the specified time(h264 flv local)
1706 * @tc.type: FUNC
1707 */
1708 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1206, TestSize.Level1)
1709 {
1710 InitResource(g_flvPath, LOCAL);
1711 ASSERT_TRUE(initStatus_);
1712 SetInitValue();
1713 for (auto idx : selectedTrackIds_) {
1714 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1715 }
1716 list<int64_t> toPtsList = {0, 1500, 1000, 1740, 1970, 2100}; // ms
1717 vector<int32_t> videoVals = {76, 76, 76, 0, 76, 0, 0, 76, 76, 0, 76, 0, 0, 76, 0, 0, 76, 0};
1718 vector<int32_t> audioVals = {107, 107, 107, 0, 107, 0, 0, 107, 107, 0, 107, 0, 0, 107, 0, 0, 107, 0};
1719 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1720 ASSERT_NE(sharedMem_, nullptr);
1721 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1722 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1723 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1724 if (ret_ != AV_ERR_OK) {
1725 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1726 continue;
1727 }
1728 ReadData();
1729 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1730 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]);
1731 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1732 ASSERT_EQ(frames_[1], audioVals[numbers_]);
1733 numbers_ += 1;
1734 RemoveValue();
1735 selectedTrackIds_.clear();
1736 }
1737 }
1738 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1739 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1740 }
1741
1742 /**
1743 * @tc.name: Demuxer_SeekToTime_1229
1744 * @tc.desc: seek to the specified time(h264 fmp4 fd)
1745 * @tc.type: FUNC
1746 */
1747 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1229, TestSize.Level1)
1748 {
1749 InitResource(g_fmp4AvcPath, LOCAL);
1750 ASSERT_TRUE(initStatus_);
1751 SetInitValue();
1752 for (auto idx : selectedTrackIds_) {
1753 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1754 }
1755 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms
1756 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602};
1757 vector<int32_t> audioVals = {433, 433, 433, 74, 254, 254, 74, 254, 74, 253, 433, 433};
1758 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1759 ASSERT_NE(sharedMem_, nullptr);
1760 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1761 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1762 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1763 if (ret_ != AV_ERR_OK) {
1764 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1765 continue;
1766 }
1767 ReadData();
1768 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1769 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]);
1770 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1771 ASSERT_EQ(frames_[1], audioVals[numbers_]);
1772 numbers_ += 1;
1773 RemoveValue();
1774 selectedTrackIds_.clear();
1775 }
1776 }
1777 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1778 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1779 }
1780
1781 /**
1782 * @tc.name: Demuxer_SeekToTime_1238
1783 * @tc.desc: seek to the specified time(fmp4 m4v fd)
1784 * @tc.type: FUNC
1785 */
1786 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1238, TestSize.Level1)
1787 {
1788 InitResource(g_fmp4m4vPath, LOCAL);
1789 ASSERT_TRUE(initStatus_);
1790 SetInitValue();
1791 for (auto idx : selectedTrackIds_) {
1792 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1793 }
1794 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms
1795 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602};
1796 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1797 ASSERT_NE(sharedMem_, nullptr);
1798 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1799 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1800 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1801 if (ret_ != AV_ERR_OK) {
1802 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1803 continue;
1804 }
1805 ReadData();
1806 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1807 ASSERT_EQ(frames_[0], videoVals[numbers_]);
1808 numbers_ += 1;
1809 RemoveValue();
1810 selectedTrackIds_.clear();
1811 }
1812 }
1813 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1814 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1815 }
1816
1817 /**
1818 * @tc.name: Demuxer_SeekToTime_1239
1819 * @tc.desc: seek to the specified time(fmp4 m4a fd)
1820 * @tc.type: FUNC
1821 */
1822 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1239, TestSize.Level1)
1823 {
1824 InitResource(g_fmp4m4aPath, LOCAL);
1825 ASSERT_TRUE(initStatus_);
1826 SetInitValue();
1827 for (auto idx : selectedTrackIds_) {
1828 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
1829 }
1830 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms
1831 vector<int32_t> audioVals = {433, 433, 433, 240, 240, 240, 132, 132, 132, 348, 348, 348};
1832 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1833 ASSERT_NE(sharedMem_, nullptr);
1834 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
1835 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
1836 ret_ = demuxer_->SeekToTime(*toPts, *mode);
1837 if (ret_ != AV_ERR_OK) {
1838 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
1839 continue;
1840 }
1841 ReadData();
1842 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
1843 ASSERT_EQ(frames_[0], audioVals[numbers_]);
1844 numbers_ += 1;
1845 RemoveValue();
1846 selectedTrackIds_.clear();
1847 }
1848 }
1849 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1850 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
1851 }
1852
1853 /**
1854 * @tc.name: Demuxer_ReadSample_3000
1855 * @tc.desc: copy current sample to buffer(srt)
1856 * @tc.type: FUNC
1857 */
1858 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_3000, TestSize.Level1)
1859 {
1860 InitResource(g_srt, LOCAL);
1861 ASSERT_TRUE(initStatus_);
1862 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1863
1864 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1865 ASSERT_NE(sharedMem_, nullptr);
1866 SetInitValue();
1867 while (!isEOS(eosFlag_)) {
1868 for (auto idx : selectedTrackIds_) {
1869 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1870 CountFrames(idx);
1871 }
1872 }
1873 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1874 ASSERT_EQ(frames_[0], 5);
1875 RemoveValue();
1876 }
1877
1878 #ifndef DEMUXER_CAPI_BUFFER_UNIT_TEST
1879 /**
1880 * @tc.name: Demuxer_ReadSample_3002
1881 * @tc.desc: copy current sample to buffer(vtt, en)
1882 * @tc.type: FUNC
1883 */
1884 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_3002, TestSize.Level1)
1885 {
1886 InitResource(g_vttPath, LOCAL);
1887 ASSERT_TRUE(initStatus_);
1888 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1889
1890 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1891 ASSERT_NE(sharedMem_, nullptr);
1892 SetInitValue();
1893 int32_t vttIndex = 0;
1894 while (!isEOS(eosFlag_)) {
1895 for (auto idx : selectedTrackIds_) {
1896 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1897 char *vttStr = static_cast<char *>(malloc(info_.size * sizeof(char) + 1));
1898 memcpy_s(vttStr, info_.size, sharedMem_->GetAddr(), info_.size);
1899 *(vttStr + info_.size) = '\0';
1900 switch (vttIndex) {
1901 case 0:
1902 ASSERT_EQ(strcmp(vttStr, "testA"), 0);
1903 ASSERT_EQ(info_.presentationTimeUs, 500000);
1904 ASSERT_EQ(info_.size, 5);
1905 break;
1906 case 1:
1907 ASSERT_EQ(strcmp(vttStr, "testBB"), 0);
1908 ASSERT_EQ(info_.presentationTimeUs, 1001000);
1909 ASSERT_EQ(info_.size, 6);
1910 break;
1911 case 2:
1912 ASSERT_EQ(strcmp(vttStr, "testCCC"), 0);
1913 ASSERT_EQ(info_.presentationTimeUs, 2003000);
1914 ASSERT_EQ(info_.size, 7);
1915 break;
1916 case 3:
1917 ASSERT_EQ(strcmp(vttStr, "testDDDD"), 0);
1918 ASSERT_EQ(info_.presentationTimeUs, 2100000);
1919 ASSERT_EQ(info_.size, 8);
1920 break;
1921 default:
1922 break;
1923 }
1924 CountFrames(idx);
1925 free(vttStr);
1926 }
1927 vttIndex++;
1928 }
1929 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1930 ASSERT_EQ(frames_[0], 4);
1931 RemoveValue();
1932 }
1933
1934 /**
1935 * @tc.name: Demuxer_ReadSample_3003
1936 * @tc.desc: copy current sample to buffer(vtt, zh)
1937 * @tc.type: FUNC
1938 */
1939 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_3003, TestSize.Level1)
1940 {
1941 InitResource(g_vttPath2, LOCAL);
1942 ASSERT_TRUE(initStatus_);
1943 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
1944
1945 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
1946 ASSERT_NE(sharedMem_, nullptr);
1947 SetInitValue();
1948 int32_t vttIndex = 0;
1949 while (!isEOS(eosFlag_)) {
1950 for (auto idx : selectedTrackIds_) {
1951 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
1952 char *vttStr = static_cast<char *>(malloc(info_.size * sizeof(char) + 1));
1953 memcpy_s(vttStr, info_.size, sharedMem_->GetAddr(), info_.size);
1954 *(vttStr + info_.size) = '\0';
1955 switch (vttIndex) {
1956 case 0:
1957 ASSERT_EQ(strcmp(vttStr, "第1帧"), 0);
1958 ASSERT_EQ(info_.presentationTimeUs, 30000);
1959 ASSERT_EQ(info_.size, 7);
1960 break;
1961 case 1:
1962 ASSERT_EQ(strcmp(vttStr, "第2帧"), 0);
1963 ASSERT_EQ(info_.presentationTimeUs, 2030000);
1964 ASSERT_EQ(info_.size, 7);
1965 break;
1966 case 2:
1967 ASSERT_EQ(strcmp(vttStr, "第3帧"), 0);
1968 ASSERT_EQ(info_.presentationTimeUs, 2900000);
1969 ASSERT_EQ(info_.size, 7);
1970 break;
1971 case 3:
1972 ASSERT_EQ(strcmp(vttStr, "第4帧"), 0);
1973 ASSERT_EQ(info_.presentationTimeUs, 3000000);
1974 ASSERT_EQ(info_.size, 7);
1975 break;
1976 default:
1977 break;
1978 }
1979 CountFrames(idx);
1980 free(vttStr);
1981 }
1982 vttIndex++;
1983 }
1984 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
1985
1986 ASSERT_EQ(frames_[0], 10);
1987 RemoveValue();
1988 }
1989 #endif
1990
1991 /**
1992 * @tc.name: Demuxer_SeekToTime_3000
1993 * @tc.desc: seek to the specified time(srt)
1994 * @tc.type: FUNC
1995 */
1996 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_3000, TestSize.Level1)
1997 {
1998 InitResource(g_srt, LOCAL);
1999 ASSERT_TRUE(initStatus_);
2000 SetInitValue();
2001 for (auto idx : selectedTrackIds_) {
2002 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
2003 }
2004 list<int64_t> toPtsList = {0, 160, 2000, 4000, 7000}; // ms
2005 vector<int32_t> subVals = {5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 2, 2, 2};
2006 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
2007 ASSERT_NE(sharedMem_, nullptr);
2008 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
2009 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
2010 ret_ = demuxer_->SeekToTime(*toPts, *mode);
2011 if (ret_ != AV_ERR_OK) {
2012 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
2013 continue;
2014 }
2015 ReadData();
2016 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
2017 ASSERT_EQ(frames_[0], subVals[numbers_]);
2018 numbers_ += 1;
2019 RemoveValue();
2020 selectedTrackIds_.clear();
2021 }
2022 }
2023 }
2024
2025 #ifndef DEMUXER_CAPI_BUFFER_UNIT_TEST
2026 /**
2027 * @tc.name: Demuxer_SeekToTime_3002
2028 * @tc.desc: seek to the specified time(vtt, en)
2029 * @tc.type: FUNC
2030 */
2031 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_3002, TestSize.Level1)
2032 {
2033 InitResource(g_vttPath, LOCAL);
2034 ASSERT_TRUE(initStatus_);
2035 SetInitValue();
2036 for (auto idx : selectedTrackIds_) {
2037 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
2038 }
2039 list<int64_t> toPtsList = {500, 1000, 2000, 3000}; // ms
2040 vector<int32_t> subVals = {4, 4, 4, 4, 4, 4, 3, 3, 3, 1, 1, 1};
2041 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
2042 ASSERT_NE(sharedMem_, nullptr);
2043 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
2044 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
2045 ret_ = demuxer_->SeekToTime(*toPts, *mode);
2046 if (ret_ != AV_ERR_OK) {
2047 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
2048 continue;
2049 }
2050 ReadData();
2051 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
2052 ASSERT_EQ(frames_[0], subVals[numbers_]);
2053 numbers_ += 1;
2054 RemoveValue();
2055 selectedTrackIds_.clear();
2056 }
2057 }
2058 }
2059
2060 /**
2061 * @tc.name: Demuxer_SeekToTime_3003
2062 * @tc.desc: seek to the specified time(vtt, zh)
2063 * @tc.type: FUNC
2064 */
2065 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_3003, TestSize.Level1)
2066 {
2067 InitResource(TEST_FILE_PATH + string("webvtt_test2.vtt"), LOCAL);
2068 ASSERT_TRUE(initStatus_);
2069 SetInitValue();
2070 for (auto idx : selectedTrackIds_) {
2071 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
2072 }
2073 list<int64_t> toPtsList = {100, 1000, 1200, 61000, 65000}; // ms
2074 vector<int32_t> subVals = {10, 10, 10, 10, 10, 10, 9, 9, 9, 1, 1, 1, 1, 1, 1};
2075 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
2076 ASSERT_NE(sharedMem_, nullptr);
2077 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
2078 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
2079 ret_ = demuxer_->SeekToTime(*toPts, *mode);
2080 if (ret_ != AV_ERR_OK) {
2081 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
2082 continue;
2083 }
2084 ReadData();
2085 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
2086 ASSERT_EQ(frames_[0], subVals[numbers_]);
2087 numbers_ += 1;
2088 RemoveValue();
2089 selectedTrackIds_.clear();
2090 }
2091 }
2092 }
2093 #endif
2094
2095 /**
2096 * @tc.name: Demuxer_SetMediaKeySystemInfoCallback_4000
2097 * @tc.desc: set normal drm callback
2098 * @tc.type: FUNC
2099 */
2100 HWTEST_F(DemuxerUnitTest, Demuxer_SetMediaKeySystemInfoCallback_4000, TestSize.Level1)
2101 {
2102 InitResource(g_drmSm4cPath, LOCAL);
2103 ASSERT_TRUE(initStatus_);
2104
2105 bool isNullCallback = false;
2106 int32_t ret = demuxer_->SetMediaKeySystemInfoCallback(isNullCallback);
2107 ASSERT_EQ(ret, AV_ERR_OK);
2108 }
2109
2110 /**
2111 * @tc.name: Demuxer_SetMediaKeySystemInfoCallback_4001
2112 * @tc.desc: set null drm callback
2113 * @tc.type: FUNC
2114 */
2115 HWTEST_F(DemuxerUnitTest, Demuxer_SetMediaKeySystemInfoCallback_4001, TestSize.Level1)
2116 {
2117 InitResource(g_drmSm4cPath, LOCAL);
2118 ASSERT_TRUE(initStatus_);
2119
2120 bool isNullCallback = true;
2121 int32_t ret = demuxer_->SetMediaKeySystemInfoCallback(isNullCallback);
2122 ASSERT_EQ(ret, AV_ERR_OK);
2123 }
2124
2125 /**
2126 * @tc.name: Demuxer_SetDemuxerMediaKeySystemInfoCallback_4002
2127 * @tc.desc: set normal drm callback
2128 * @tc.type: FUNC
2129 */
2130 HWTEST_F(DemuxerUnitTest, Demuxer_SetDemuxerMediaKeySystemInfoCallback_4002, TestSize.Level1)
2131 {
2132 InitResource(g_drmSm4cPath, LOCAL);
2133 ASSERT_TRUE(initStatus_);
2134
2135 bool isNullCallback = false;
2136 int32_t ret = demuxer_->SetDemuxerMediaKeySystemInfoCallback(isNullCallback);
2137 ASSERT_EQ(ret, AV_ERR_OK);
2138 }
2139
2140 /**
2141 * @tc.name: Demuxer_SetDemuxerMediaKeySystemInfoCallback_4003
2142 * @tc.desc: set null drm callback
2143 * @tc.type: FUNC
2144 */
2145 HWTEST_F(DemuxerUnitTest, Demuxer_SetDemuxerMediaKeySystemInfoCallback_4003, TestSize.Level1)
2146 {
2147 InitResource(g_drmSm4cPath, LOCAL);
2148 ASSERT_TRUE(initStatus_);
2149
2150 bool isNullCallback = true;
2151 int32_t ret = demuxer_->SetDemuxerMediaKeySystemInfoCallback(isNullCallback);
2152 ASSERT_EQ(ret, AV_ERR_OK);
2153 }
2154
2155 /**
2156 * @tc.name: Demuxer_GetMediaKeySystemInfo_4004
2157 * @tc.desc: get drm info when play drm
2158 * @tc.type: FUNC
2159 */
2160 HWTEST_F(DemuxerUnitTest, Demuxer_GetMediaKeySystemInfo_4004, TestSize.Level1)
2161 {
2162 InitResource(g_drmSm4cPath, LOCAL);
2163 ASSERT_TRUE(initStatus_);
2164
2165 int32_t ret = demuxer_->GetMediaKeySystemInfo();
2166 ASSERT_EQ(ret, AV_ERR_OK);
2167 }
2168
2169 #ifndef DEMUXER_CAPI_UNIT_TEST
2170 /**
2171 * @tc.name: Demuxer_GetIndexByRelativePresentationTimeUs_1000
2172 * @tc.desc: Get index by pts(audio track)
2173 * @tc.type: FUNC
2174 */
2175 HWTEST_F(DemuxerUnitTest, Demuxer_GetIndexByRelativePresentationTimeUs_1000, TestSize.Level1)
2176 {
2177 InitResource(g_ptsConversionPath, LOCAL);
2178 ASSERT_TRUE(initStatus_);
2179
2180 uint32_t trackIndex = 0;
2181 uint64_t relativePresentationTimeUs = 69659;
2182 uint32_t index = 0;
2183
2184 int32_t ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index);
2185 ASSERT_EQ(ret, AV_ERR_OK);
2186
2187 ASSERT_EQ(index, 3);
2188 }
2189
2190 /**
2191 * @tc.name: Demuxer_GetIndexByRelativePresentationTimeUs_1001
2192 * @tc.desc: Get index by pts(video track)
2193 * @tc.type: FUNC
2194 */
2195 HWTEST_F(DemuxerUnitTest, Demuxer_GetIndexByRelativePresentationTimeUs_1001, TestSize.Level1)
2196 {
2197 InitResource(g_ptsConversionPath, LOCAL);
2198 ASSERT_TRUE(initStatus_);
2199
2200 uint32_t trackIndex = 1;
2201 uint64_t relativePresentationTimeUs = 66666;
2202 uint32_t index = 0;
2203
2204 int32_t ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index);
2205 ASSERT_EQ(ret, AV_ERR_OK);
2206
2207 ASSERT_EQ(index, 4);
2208 }
2209
2210 /**
2211 * @tc.name: Demuxer_GetIndexByRelativePresentationTimeUs_1002
2212 * @tc.desc: Get index by pts(not MP4)
2213 * @tc.type: FUNC
2214 */
2215 HWTEST_F(DemuxerUnitTest, Demuxer_GetIndexByRelativePresentationTimeUs_1002, TestSize.Level1)
2216 {
2217 InitResource(g_flvPath, LOCAL);
2218 ASSERT_TRUE(initStatus_);
2219
2220 uint32_t trackIndex = 0;
2221 uint64_t relativePresentationTimeUs = 69659;
2222 uint32_t index = 0;
2223
2224 int32_t ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index);
2225 ASSERT_NE(ret, AV_ERR_OK);
2226
2227 ASSERT_EQ(index, 0);
2228 }
2229
2230 /**
2231 * @tc.name: Demuxer_GetIndexByRelativePresentationTimeUs_1003
2232 * @tc.desc: Get index by pts(non-standard pts & different track)
2233 * @tc.type: FUNC
2234 */
2235 HWTEST_F(DemuxerUnitTest, Demuxer_GetIndexByRelativePresentationTimeUs_1003, TestSize.Level1)
2236 {
2237 InitResource(g_ptsConversionPath, LOCAL);
2238 ASSERT_TRUE(initStatus_);
2239
2240 // standard pts & video track
2241 uint32_t trackIndex = 1;
2242 uint64_t relativePresentationTimeUs = 166666;
2243 uint32_t index = 0;
2244 int32_t ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index);
2245 ASSERT_EQ(ret, AV_ERR_OK);
2246 ASSERT_EQ(index, 10);
2247 }
2248
2249 /**
2250 * @tc.name: Demuxer_GetRelativePresentationTimeUsByIndex_1000
2251 * @tc.desc: get pts by frameIndex(audio track)
2252 * @tc.type: FUNC
2253 */
2254 HWTEST_F(DemuxerUnitTest, Demuxer_GetRelativePresentationTimeUsByIndex_1000, TestSize.Level1)
2255 {
2256 InitResource(g_ptsConversionPath, LOCAL);
2257 ASSERT_TRUE(initStatus_);
2258
2259 uint32_t trackIndex = 0;
2260 uint64_t relativePresentationTimeUs = 0;
2261 uint32_t index = 2;
2262
2263 int32_t ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs);
2264 ASSERT_EQ(ret, AV_ERR_OK);
2265
2266 ASSERT_EQ(relativePresentationTimeUs, 46439);
2267 }
2268
2269 /**
2270 * @tc.name: Demuxer_GetRelativePresentationTimeUsByIndex_1001
2271 * @tc.desc: get pts by frameIndex(video track)
2272 * @tc.type: FUNC
2273 */
2274 HWTEST_F(DemuxerUnitTest, Demuxer_GetRelativePresentationTimeUsByIndex_1001, TestSize.Level1)
2275 {
2276 InitResource(g_ptsConversionPath, LOCAL);
2277 ASSERT_TRUE(initStatus_);
2278
2279 uint32_t trackIndex = 1;
2280 uint64_t relativePresentationTimeUs = 0;
2281 uint32_t index = 2;
2282
2283 int32_t ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs);
2284 ASSERT_EQ(ret, AV_ERR_OK);
2285
2286 ASSERT_EQ(relativePresentationTimeUs, 33333);
2287 }
2288
2289 /**
2290 * @tc.name: Demuxer_GetRelativePresentationTimeUsByIndex_1002
2291 * @tc.desc: get pts by frameIndex(not MP4)
2292 * @tc.type: FUNC
2293 */
2294 HWTEST_F(DemuxerUnitTest, Demuxer_GetRelativePresentationTimeUsByIndex_1002, TestSize.Level1)
2295 {
2296 InitResource(g_flvPath, LOCAL);
2297 ASSERT_TRUE(initStatus_);
2298
2299 uint32_t trackIndex = 0;
2300 uint64_t relativePresentationTimeUs = 0;
2301 uint32_t index = 10;
2302
2303 int32_t ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs);
2304 ASSERT_NE(ret, AV_ERR_OK);
2305
2306 ASSERT_EQ(relativePresentationTimeUs, 0);
2307 }
2308
2309 /**
2310 * @tc.name: Demuxer_PtsAndFrameIndexConversion_1000
2311 * @tc.desc: pts and frameIndex convertion test(pts -> frameIndex -> pts)
2312 * @tc.type: FUNC
2313 */
2314 HWTEST_F(DemuxerUnitTest, Demuxer_PtsAndFrameIndexConversion_1000, TestSize.Level1)
2315 {
2316 InitResource(g_ptsConversionPath, LOCAL);
2317 ASSERT_TRUE(initStatus_);
2318
2319 uint32_t trackIndex = 0;
2320 uint64_t relativePresentationTimeUs = 92879;
2321 uint32_t index = 0;
2322
2323 int32_t ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index);
2324 ASSERT_EQ(ret, AV_ERR_OK);
2325 ASSERT_EQ(index, 4);
2326
2327 uint64_t relativePresentationTimeUs1 = 0;
2328
2329 ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs1);
2330 ASSERT_EQ(ret, AV_ERR_OK);
2331 ASSERT_EQ(relativePresentationTimeUs1, 92879);
2332 }
2333
2334 /**
2335 * @tc.name: Demuxer_PtsAndFrameIndexConversion_1001
2336 * @tc.desc: pts and frameIndex convertion test(frameIndex -> pts -> frameIndex)
2337 * @tc.type: FUNC
2338 */
2339 HWTEST_F(DemuxerUnitTest, Demuxer_PtsAndFrameIndexConversion_1001, TestSize.Level1)
2340 {
2341 InitResource(g_ptsConversionPath, LOCAL);
2342 ASSERT_TRUE(initStatus_);
2343
2344 uint32_t trackIndex = 0;
2345 uint64_t relativePresentationTimeUs = 0;
2346 uint32_t index = 4;
2347
2348 int32_t ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs);
2349 ASSERT_EQ(ret, AV_ERR_OK);
2350 ASSERT_EQ(relativePresentationTimeUs, 92879);
2351
2352 uint32_t index1 = 0;
2353
2354 ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index1);
2355 ASSERT_EQ(ret, AV_ERR_OK);
2356 ASSERT_EQ(index1, 4);
2357 }
2358
2359 /**
2360 * @tc.name: Demuxer_PTSOutOfRange_1000
2361 * @tc.desc: pts out of range
2362 * @tc.type: FUNC
2363 */
2364 HWTEST_F(DemuxerUnitTest, Demuxer_PTSOutOfRange_1000, TestSize.Level1)
2365 {
2366 InitResource(g_ptsConversionPath, LOCAL);
2367 ASSERT_TRUE(initStatus_);
2368
2369 uint32_t trackIndex = 0;
2370 uint64_t relativePresentationTimeUs = 999999999;
2371 uint32_t index = 0;
2372 int32_t ret = demuxer_->GetIndexByRelativePresentationTimeUs(trackIndex, relativePresentationTimeUs, index);
2373 ASSERT_NE(ret, AV_ERR_OK);
2374 }
2375
2376 /**
2377 * @tc.name: Demuxer_IndexOutOfRange_1000
2378 * @tc.desc: Index out of range
2379 * @tc.type: FUNC
2380 */
2381 HWTEST_F(DemuxerUnitTest, Demuxer_IndexOutOfRange_1000, TestSize.Level1)
2382 {
2383 InitResource(g_ptsConversionPath, LOCAL);
2384 ASSERT_TRUE(initStatus_);
2385
2386 uint32_t trackIndex = 0;
2387 uint64_t relativePresentationTimeUs = 0;
2388 uint32_t index = 9999999;
2389 int32_t ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs);
2390 ASSERT_NE(ret, AV_ERR_OK);
2391 }
2392
2393 /**
2394 * @tc.name: Demuxer_TrackOutOfRange_1000
2395 * @tc.desc: Track out of range
2396 * @tc.type: FUNC
2397 */
2398 HWTEST_F(DemuxerUnitTest, Demuxer_TrackOutOfRange_1000, TestSize.Level1)
2399 {
2400 InitResource(g_ptsConversionPath, LOCAL);
2401 ASSERT_TRUE(initStatus_);
2402
2403 uint32_t trackIndex = 99;
2404 uint64_t relativePresentationTimeUs = 0;
2405 uint32_t index = 0;
2406 int32_t ret = demuxer_->GetRelativePresentationTimeUsByIndex(trackIndex, index, relativePresentationTimeUs);
2407 ASSERT_NE(ret, AV_ERR_OK);
2408 }
2409
2410 #endif
2411
2412 /**
2413 * @tc.name: Demuxer_ReadSample_1601
2414 * @tc.desc: copy current sample to buffer(mp4 vvc)
2415 * @tc.type: FUNC
2416 */
2417 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1601, TestSize.Level1)
2418 {
2419 if (access(g_mp4VvcPath.c_str(), F_OK) != 0) {
2420 return;
2421 }
2422 InitResource(g_mp4VvcPath, LOCAL);
2423 ASSERT_TRUE(initStatus_);
2424 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK);
2425 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
2426 ASSERT_NE(sharedMem_, nullptr);
2427 SetInitValue();
2428 uint32_t idx = 0;
2429 while (!isEOS(eosFlag_)) {
2430 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK);
2431 CountFrames(idx);
2432 }
2433 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
2434 ASSERT_EQ(frames_[0], 600);
2435 ASSERT_EQ(keyFrames_[0], 10);
2436 RemoveValue();
2437 }
2438
2439 /**
2440 * @tc.name: Demuxer_SeekToTime_1601
2441 * @tc.desc: seek to the specified time(mp4 vvc fd)
2442 * @tc.type: FUNC
2443 */
2444 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1601, TestSize.Level1)
2445 {
2446 if (access(g_mp4VvcPath.c_str(), F_OK) != 0) {
2447 return;
2448 }
2449 InitResource(g_mp4VvcPath, LOCAL);
2450 ASSERT_TRUE(initStatus_);
2451 SetInitValue();
2452 for (auto idx : selectedTrackIds_) {
2453 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK);
2454 }
2455 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms
2456 vector<int32_t> audioVals = {433, 433, 433, 240, 240, 240, 132, 132, 132, 348, 348, 348};
2457 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_);
2458 ASSERT_NE(sharedMem_, nullptr);
2459 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) {
2460 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) {
2461 ret_ = demuxer_->SeekToTime(*toPts, *mode);
2462 if (ret_ != AV_ERR_OK) {
2463 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_);
2464 continue;
2465 }
2466 ReadData();
2467 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]);
2468 numbers_ += 1;
2469 RemoveValue();
2470 selectedTrackIds_.clear();
2471 }
2472 }
2473 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
2474 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK);
2475 }
2476 } // namespace
2477