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