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 URI false 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 static const string TEST_URI_PATH2 = "http://192.168.3.11:8080/share/"; 42 43 list<SeekMode> seekModes = {SeekMode::SEEK_NEXT_SYNC, SeekMode::SEEK_PREVIOUS_SYNC, 44 SeekMode::SEEK_CLOSEST_SYNC}; 45 string g_mp4Uri = TEST_URI_PATH + string("test_264_B_Gop25_4sec_cover.mp4"); 46 string g_mp4Uri2 = TEST_URI_PATH + string("test_mpeg2_B_Gop25_4sec.mp4"); 47 string g_mp4Uri4 = TEST_URI_PATH + string("zero_track.mp4"); 48 string g_mkvUri2 = TEST_URI_PATH + string("h264_opus_4sec.mkv"); 49 string g_tsUri = TEST_URI_PATH + string("test_mpeg2_Gop25_4sec.ts"); 50 string g_aacUri = TEST_URI_PATH + string("audio/aac_44100_1.aac"); 51 string g_flacUri = TEST_URI_PATH + string("audio/flac_48000_1_cover.flac"); 52 string g_m4aUri = TEST_URI_PATH + string("audio/m4a_48000_1.m4a"); 53 string g_mp3Uri = TEST_URI_PATH + string("audio/mp3_48000_1_cover.mp3"); 54 string g_oggUri = TEST_URI_PATH + string("audio/ogg_48000_1.ogg"); 55 string g_wavUri = TEST_URI_PATH + string("audio/wav_48000_1.wav"); 56 string g_amrUri = TEST_URI_PATH + string("audio/amr_nb_8000_1.amr"); 57 string g_amrUri2 = TEST_URI_PATH + string("audio/amr_wb_16000_1.amr"); 58 string g_audioVividUri = TEST_URI_PATH + string("2obj_44100Hz_16bit_32k.m4a"); 59 string g_apeUri = TEST_URI_PATH + string("ape_test.ape"); 60 string g_flvUri = TEST_URI_PATH + string("h264.flv"); 61 string g_fmp4AvcUri = TEST_URI_PATH + string("h264_fmp4.mp4"); 62 string g_fmp4m4vUri = TEST_URI_PATH + string("h264_fmp4.m4v"); 63 string g_fmp4m4aUri = TEST_URI_PATH + string("audio/h264_fmp4.m4a"); 64 string g_hls = TEST_URI_PATH2 + string("index_264.m3u8"); 65 string g_srt = TEST_URI_PATH + string("subtitle.srt"); 66 string g_mp4VvcUri = TEST_URI_PATH + string("vvc.mp4"); 67 string g_mp4VvcPath = TEST_FILE_PATH + string("vvc.mp4"); 68 69 std::map<std::string, std::map<std::string, std::vector<int32_t>>> infoMap = { 70 {"ape", {{"frames", {7}}, {"kFrames", {7}}}}, 71 }; 72 73 /** 74 * @tc.name: Demuxer_CreateDemuxer_2000 75 * @tc.desc: create demuxer(URI) 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_2000, TestSize.Level1) 79 { 80 printf("---- %s ------\n", g_mp4Uri.data()); 81 source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data())); 82 ASSERT_NE(source_, nullptr); 83 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_); 84 ASSERT_NE(demuxer_, nullptr); 85 } 86 87 /** 88 * @tc.name: Demuxer_CreateDemuxer_2010 89 * @tc.desc: repeatedly create demuxer 90 * @tc.type: FUNC 91 */ 92 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_2010, TestSize.Level1) 93 { 94 printf("---- %s ------\n", g_mp4Uri.data()); 95 source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data())); 96 ASSERT_NE(source_, nullptr); 97 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_); 98 ASSERT_NE(demuxer_, nullptr); 99 shared_ptr<DemuxerMock> demuxer2 = AVDemuxerMockFactory::CreateDemuxer(source_); 100 ASSERT_NE(demuxer2, nullptr); 101 ASSERT_EQ(demuxer2->Destroy(), AV_ERR_OK); 102 demuxer2 = nullptr; 103 } 104 105 /** 106 * @tc.name: Demuxer_CreateDemuxer_2020 107 * @tc.desc: create demuxer 108 * @tc.type: FUNC 109 */ 110 HWTEST_F(DemuxerUnitTest, Demuxer_CreateDemuxer_2300, TestSize.Level1) 111 { 112 printf("---- %s ------\n", g_mp4Uri4.data()); 113 source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri4.data())); 114 ASSERT_NE(source_, nullptr); 115 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_); 116 ASSERT_NE(demuxer_, nullptr); 117 } 118 119 /** 120 * @tc.name: Demuxer_UnselectTrackByID_2000 121 * @tc.desc: select and remove track by ID 122 * @tc.type: FUNC 123 */ 124 HWTEST_F(DemuxerUnitTest, Demuxer_UnselectTrackByID_2000, TestSize.Level1) 125 { 126 printf("---- %s ------\n", g_mp4Uri.data()); 127 source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data())); 128 ASSERT_NE(source_, nullptr); 129 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_); 130 ASSERT_NE(demuxer_, nullptr); 131 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 132 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 133 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK); 134 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 135 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK); 136 ASSERT_EQ(demuxer_->UnselectTrackByID(1), AV_ERR_OK); 137 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK); 138 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK); 139 } 140 141 /** 142 * @tc.name: Demuxer_ReadSample_2000 143 * @tc.desc: copy current sample to buffer 144 * @tc.type: FUNC 145 */ 146 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2000, TestSize.Level1) 147 { 148 InitResource(g_mp4Uri, URI); 149 ASSERT_TRUE(initStatus_); 150 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 151 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 152 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 153 ASSERT_NE(sharedMem_, nullptr); 154 ASSERT_TRUE(SetInitValue()); 155 while (!isEOS(eosFlag_)) { 156 for (auto idx : selectedTrackIds_) { 157 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 158 CountFrames(idx); 159 } 160 } 161 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 162 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 163 ASSERT_EQ(frames_[0], 103); 164 ASSERT_EQ(frames_[1], 174); 165 ASSERT_EQ(keyFrames_[0], 5); 166 ASSERT_EQ(keyFrames_[1], 174); 167 RemoveValue(); 168 } 169 170 /** 171 * @tc.name: Demuxer_ReadSample_2010 172 * @tc.desc: copy current sample to buffer 173 * @tc.type: FUNC 174 */ 175 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2010, TestSize.Level1) 176 { 177 printf("---- %s ------\n", g_mp4Uri.data()); 178 source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data())); 179 ASSERT_NE(source_, nullptr); 180 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_); 181 ASSERT_NE(demuxer_, nullptr); 182 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 183 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 184 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 185 ASSERT_NE(sharedMem_, nullptr); 186 uint32_t idx = 4; 187 ASSERT_NE(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 188 } 189 190 /** 191 * @tc.name: Demuxer_ReadSample_2020 192 * @tc.desc: copy current sample to buffer 193 * @tc.type: FUNC 194 */ 195 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2020, TestSize.Level1) 196 { 197 printf("---- %s ------\n", g_mp4Uri.data()); 198 source_ = AVSourceMockFactory::CreateSourceWithURI(const_cast<char*>(g_mp4Uri.data())); 199 ASSERT_NE(source_, nullptr); 200 demuxer_ = AVDemuxerMockFactory::CreateDemuxer(source_); 201 ASSERT_NE(demuxer_, nullptr); 202 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 203 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 204 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 205 ASSERT_NE(sharedMem_, nullptr); 206 uint32_t idx = -1; 207 ASSERT_NE(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 208 } 209 210 /** 211 * @tc.name: Demuxer_ReadSample_2030 212 * @tc.desc: copy current sample to buffer 213 * @tc.type: FUNC 214 */ 215 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2030, TestSize.Level1) 216 { 217 InitResource(g_mp4Uri, URI); 218 ASSERT_TRUE(initStatus_); 219 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 220 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 221 ASSERT_NE(sharedMem_, nullptr); 222 int32_t vkeyFrames = 0; 223 int32_t vframes = 0; 224 flag_ = AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE; 225 while (!(flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS)) { 226 ASSERT_EQ(demuxer_->ReadSample(0, sharedMem_, &info_, flag_), AV_ERR_OK); 227 if (flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_EOS) { 228 break; 229 } 230 if (flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_SYNC_FRAME) { 231 vkeyFrames++; 232 vframes++; 233 } else if ((flag_ & AVCodecBufferFlag::AVCODEC_BUFFER_FLAG_NONE) == 0) { 234 vframes++; 235 } 236 } 237 printf("vframes=%d | vkFrames=%d\n", vframes, vkeyFrames); 238 ASSERT_EQ(vframes, 103); 239 ASSERT_EQ(vkeyFrames, 5); 240 } 241 242 /** 243 * @tc.name: Demuxer_ReadSample_2040 244 * @tc.desc: copy current sample to buffer 245 * @tc.type: FUNC 246 */ 247 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2040, TestSize.Level1) 248 { 249 InitResource(g_mp4Uri2, URI); 250 ASSERT_TRUE(initStatus_); 251 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 252 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 253 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 254 ASSERT_NE(sharedMem_, nullptr); 255 ASSERT_TRUE(SetInitValue()); 256 while (!isEOS(eosFlag_)) { 257 for (auto idx : selectedTrackIds_) { 258 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 259 CountFrames(idx); 260 } 261 } 262 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 263 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 264 ASSERT_EQ(frames_[0], 103); 265 ASSERT_EQ(frames_[1], 174); 266 ASSERT_EQ(keyFrames_[0], 5); 267 ASSERT_EQ(keyFrames_[1], 174); 268 RemoveValue(); 269 } 270 271 /** 272 * @tc.name: Demuxer_ReadSample_2060 273 * @tc.desc: copy current sample to buffer 274 * @tc.type: FUNC 275 */ 276 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2060, TestSize.Level1) 277 { 278 InitResource(g_mkvUri2, URI); 279 ASSERT_TRUE(initStatus_); 280 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 281 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 282 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 283 ASSERT_NE(sharedMem_, nullptr); 284 ASSERT_TRUE(SetInitValue()); 285 while (!isEOS(eosFlag_)) { 286 for (auto idx : selectedTrackIds_) { 287 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 288 CountFrames(idx); 289 } 290 } 291 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 292 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 293 ASSERT_EQ(frames_[0], 240); 294 ASSERT_EQ(frames_[1], 199); 295 ASSERT_EQ(keyFrames_[0], 4); 296 ASSERT_EQ(keyFrames_[1], 199); 297 RemoveValue(); 298 } 299 300 /** 301 * @tc.name: Demuxer_ReadSample_2070 302 * @tc.desc: copy current sample to buffer 303 * @tc.type: FUNC 304 */ 305 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2070, TestSize.Level1) 306 { 307 InitResource(g_tsUri, URI); 308 ASSERT_TRUE(initStatus_); 309 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 310 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 311 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 312 ASSERT_NE(sharedMem_, nullptr); 313 ASSERT_TRUE(SetInitValue()); 314 while (!isEOS(eosFlag_)) { 315 for (auto idx : selectedTrackIds_) { 316 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 317 CountFrames(idx); 318 } 319 } 320 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 321 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 322 ASSERT_EQ(frames_[0], 103); 323 ASSERT_EQ(frames_[1], 174); 324 ASSERT_EQ(keyFrames_[0], 5); 325 ASSERT_EQ(keyFrames_[1], 174); 326 RemoveValue(); 327 } 328 329 /** 330 * @tc.name: Demuxer_ReadSample_2080 331 * @tc.desc: copy current sample to buffer 332 * @tc.type: FUNC 333 */ 334 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2080, TestSize.Level1) 335 { 336 InitResource(g_aacUri, URI); 337 ASSERT_TRUE(initStatus_); 338 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 339 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 340 ASSERT_NE(sharedMem_, nullptr); 341 ASSERT_TRUE(SetInitValue()); 342 uint32_t idx = 0; 343 while (!isEOS(eosFlag_)) { 344 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 345 CountFrames(idx); 346 } 347 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 348 ASSERT_EQ(frames_[0], 1293); 349 ASSERT_EQ(keyFrames_[0], 1293); 350 RemoveValue(); 351 } 352 353 /** 354 * @tc.name: Demuxer_ReadSample_2090 355 * @tc.desc: copy current sample to buffer 356 * @tc.type: FUNC 357 */ 358 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2090, TestSize.Level1) 359 { 360 InitResource(g_flacUri, URI); 361 ASSERT_TRUE(initStatus_); 362 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 363 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 364 ASSERT_NE(sharedMem_, nullptr); 365 ASSERT_TRUE(SetInitValue()); 366 uint32_t idx = 0; 367 while (!isEOS(eosFlag_)) { 368 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 369 CountFrames(idx); 370 } 371 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 372 ASSERT_EQ(frames_[0], 313); 373 ASSERT_EQ(keyFrames_[0], 313); 374 RemoveValue(); 375 } 376 377 /** 378 * @tc.name: Demuxer_ReadSample_2100 379 * @tc.desc: copy current sample to buffer 380 * @tc.type: FUNC 381 */ 382 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2100, TestSize.Level1) 383 { 384 InitResource(g_m4aUri, URI); 385 ASSERT_TRUE(initStatus_); 386 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 387 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 388 ASSERT_NE(sharedMem_, nullptr); 389 ASSERT_TRUE(SetInitValue()); 390 uint32_t idx = 0; 391 while (!isEOS(eosFlag_)) { 392 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 393 CountFrames(idx); 394 } 395 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 396 ASSERT_EQ(frames_[0], 1408); 397 ASSERT_EQ(keyFrames_[0], 1408); 398 RemoveValue(); 399 } 400 401 /** 402 * @tc.name: Demuxer_ReadSample_2110 403 * @tc.desc: copy current sample to buffer 404 * @tc.type: FUNC 405 */ 406 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2110, TestSize.Level1) 407 { 408 InitResource(g_mp3Uri, URI); 409 ASSERT_TRUE(initStatus_); 410 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 411 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 412 ASSERT_NE(sharedMem_, nullptr); 413 ASSERT_TRUE(SetInitValue()); 414 uint32_t idx = 0; 415 while (!isEOS(eosFlag_)) { 416 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 417 CountFrames(idx); 418 } 419 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 420 ASSERT_EQ(frames_[0], 1251); 421 ASSERT_EQ(keyFrames_[0], 1251); 422 RemoveValue(); 423 } 424 425 /** 426 * @tc.name: Demuxer_ReadSample_2120 427 * @tc.desc: copy current sample to buffer 428 * @tc.type: FUNC 429 */ 430 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2120, TestSize.Level1) 431 { 432 InitResource(g_oggUri, URI); 433 ASSERT_TRUE(initStatus_); 434 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 435 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 436 ASSERT_NE(sharedMem_, nullptr); 437 ASSERT_TRUE(SetInitValue()); 438 uint32_t idx = 0; 439 while (!isEOS(eosFlag_)) { 440 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 441 CountFrames(idx); 442 } 443 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 444 ASSERT_EQ(frames_[0], 1598); 445 ASSERT_EQ(keyFrames_[0], 1598); 446 RemoveValue(); 447 } 448 449 /** 450 * @tc.name: Demuxer_ReadSample_2130 451 * @tc.desc: copy current sample to buffer 452 * @tc.type: FUNC 453 */ 454 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2130, TestSize.Level1) 455 { 456 InitResource(g_wavUri, URI); 457 ASSERT_TRUE(initStatus_); 458 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 459 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 460 ASSERT_NE(sharedMem_, nullptr); 461 ASSERT_TRUE(SetInitValue()); 462 uint32_t idx = 0; 463 while (!isEOS(eosFlag_)) { 464 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 465 CountFrames(idx); 466 } 467 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 468 ASSERT_EQ(frames_[0], 704); 469 ASSERT_EQ(keyFrames_[0], 704); 470 RemoveValue(); 471 } 472 473 /** 474 * @tc.name: Demuxer_ReadSample_2140 475 * @tc.desc: copy current sample to buffer 476 * @tc.type: FUNC 477 */ 478 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2140, TestSize.Level1) 479 { 480 InitResource(g_amrUri, URI); 481 ASSERT_TRUE(initStatus_); 482 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 483 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 484 ASSERT_NE(sharedMem_, nullptr); 485 ASSERT_TRUE(SetInitValue()); 486 uint32_t idx = 0; 487 while (!isEOS(eosFlag_)) { 488 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 489 CountFrames(idx); 490 } 491 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 492 ASSERT_EQ(frames_[0], 1501); 493 ASSERT_EQ(keyFrames_[0], 1501); 494 RemoveValue(); 495 } 496 497 /** 498 * @tc.name: Demuxer_ReadSample_1233 499 * @tc.desc: copy current sample to buffer 500 * @tc.type: FUNC 501 */ 502 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1233, TestSize.Level1) 503 { 504 InitResource(g_fmp4AvcUri, URI); 505 ASSERT_TRUE(initStatus_); 506 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 507 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 508 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 509 ASSERT_NE(sharedMem_, nullptr); 510 ASSERT_TRUE(SetInitValue()); 511 while (!isEOS(eosFlag_)) { 512 for (auto idx : selectedTrackIds_) { 513 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 514 CountFrames(idx); 515 } 516 } 517 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 518 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 519 ASSERT_EQ(frames_[0], 602); 520 ASSERT_EQ(frames_[1], 433); 521 ASSERT_EQ(keyFrames_[0], 3); 522 ASSERT_EQ(keyFrames_[1], 433); 523 RemoveValue(); 524 } 525 526 /** 527 * @tc.name: Demuxer_ReadSample_1233 528 * @tc.desc: copy current sample to buffer 529 * @tc.type: FUNC 530 */ 531 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1235, TestSize.Level1) 532 { 533 InitResource(g_fmp4m4vUri, URI); 534 ASSERT_TRUE(initStatus_); 535 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 536 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 537 ASSERT_NE(sharedMem_, nullptr); 538 ASSERT_TRUE(SetInitValue()); 539 while (!isEOS(eosFlag_)) { 540 for (auto idx : selectedTrackIds_) { 541 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 542 CountFrames(idx); 543 } 544 } 545 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 546 ASSERT_EQ(frames_[0], 602); 547 ASSERT_EQ(keyFrames_[0], 3); 548 RemoveValue(); 549 } 550 551 /** 552 * @tc.name: Demuxer_ReadSample_1233 553 * @tc.desc: copy current sample to buffer 554 * @tc.type: FUNC 555 */ 556 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1237, TestSize.Level1) 557 { 558 InitResource(g_fmp4m4aUri, URI); 559 ASSERT_TRUE(initStatus_); 560 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 561 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 562 ASSERT_NE(sharedMem_, nullptr); 563 ASSERT_TRUE(SetInitValue()); 564 while (!isEOS(eosFlag_)) { 565 for (auto idx : selectedTrackIds_) { 566 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 567 CountFrames(idx); 568 } 569 } 570 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 571 ASSERT_EQ(frames_[0], 433); 572 ASSERT_EQ(keyFrames_[0], 433); 573 RemoveValue(); 574 } 575 576 /** 577 * @tc.name: Demuxer_SeekToTime_2000 578 * @tc.desc: seek to the specified time 579 * @tc.type: FUNC 580 */ 581 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2000, TestSize.Level1) 582 { 583 InitResource(g_mp4Uri, URI); 584 ASSERT_TRUE(initStatus_); 585 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 586 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 587 list<int64_t> toPtsList = {0, 2000, 1920, 2160, 2200, 2440, 2600, 2700, 4080, 4100}; // ms 588 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, 589 47, 91, 47, 5, 5, 5, 5}; 590 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, 591 28, 53, 28, 3, 3, 3, 3}; 592 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 593 ASSERT_NE(sharedMem_, nullptr); 594 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 595 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 596 ret_ = demuxer_->SeekToTime(*toPts, *mode); 597 if (ret_ != AV_ERR_OK) { 598 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 599 continue; 600 } 601 ReadData(); 602 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 603 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 604 ASSERT_EQ(frames_[0], videoVals[numbers_]); 605 ASSERT_EQ(frames_[1], audioVals[numbers_]); 606 numbers_ += 1; 607 RemoveValue(); 608 selectedTrackIds_.clear(); 609 } 610 } 611 } 612 613 /** 614 * @tc.name: Demuxer_SeekToTime_2001 615 * @tc.desc: seek to the specified time 616 * @tc.type: FUNC 617 */ 618 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2001, TestSize.Level1) 619 { 620 InitResource(g_mp4Uri, URI); 621 ASSERT_TRUE(initStatus_); 622 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 623 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 624 list<int64_t> toPtsList = {-100, 1000000}; // ms 625 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 626 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 627 ASSERT_NE(sharedMem_, nullptr); 628 ret_ = demuxer_->SeekToTime(*toPts, SeekMode::SEEK_NEXT_SYNC); 629 ASSERT_NE(ret_, AV_ERR_OK); 630 ret_ = demuxer_->SeekToTime(*toPts, SeekMode::SEEK_PREVIOUS_SYNC); 631 ASSERT_NE(ret_, AV_ERR_OK); 632 ret_ = demuxer_->SeekToTime(*toPts, SeekMode::SEEK_CLOSEST_SYNC); 633 ASSERT_NE(ret_, AV_ERR_OK); 634 if (sharedMem_ != nullptr) { 635 sharedMem_->Destory(); 636 sharedMem_ = nullptr; 637 } 638 } 639 } 640 641 /** 642 * @tc.name: Demuxer_SeekToTime_2002 643 * @tc.desc: seek to the specified time 644 * @tc.type: FUNC 645 */ 646 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2002, TestSize.Level1) 647 { 648 InitResource(g_mp4Uri, URI); 649 ASSERT_TRUE(initStatus_); 650 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 651 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 652 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 653 ASSERT_NE(sharedMem_, nullptr); 654 int readNum = 121; 655 int64_t seekTime = 0; 656 ReadData(readNum, seekTime); 657 seekTime = (seekTime / 1000) + 500; 658 ASSERT_EQ(demuxer_->SeekToTime(seekTime, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 659 ASSERT_EQ(demuxer_->ReadSample(0, sharedMem_, &info_, flag_), AV_ERR_OK); 660 printf("time = %" PRId64 " | pts = %" PRId64 "\n", seekTime, info_.presentationTimeUs); 661 } 662 663 /** 664 * @tc.name: Demuxer_SeekToTime_2010 665 * @tc.desc: seek to the specified time 666 * @tc.type: FUNC 667 */ 668 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2010, TestSize.Level1) 669 { 670 InitResource(g_mp4Uri2, URI); 671 ASSERT_TRUE(initStatus_); 672 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 673 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 674 list<int64_t> toPtsList = {0, 3000, 2040, 1880, 1960, 2400, 2720, 2830, 4040, 4100}; // ms 675 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, 676 48, 91, 48, 8, 8, 8, 8}; 677 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, 678 30, 54, 30, 6, 6, 6, 6}; 679 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 680 ASSERT_NE(sharedMem_, nullptr); 681 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 682 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 683 ret_ = demuxer_->SeekToTime(*toPts, *mode); 684 if (ret_ != AV_ERR_OK) { 685 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 686 continue; 687 } 688 ReadData(); 689 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 690 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 691 ASSERT_EQ(frames_[0], videoVals[numbers_]); 692 ASSERT_EQ(frames_[1], audioVals[numbers_]); 693 numbers_ += 1; 694 RemoveValue(); 695 selectedTrackIds_.clear(); 696 } 697 } 698 } 699 700 /** 701 * @tc.name: Demuxer_SeekToTime_2040 702 * @tc.desc: seek to the specified time 703 * @tc.type: FUNC 704 */ 705 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2040, TestSize.Level1) 706 { 707 InitResource(g_mkvUri2, URI); 708 ASSERT_TRUE(initStatus_); 709 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 710 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 711 list<int64_t> toPtsList = {0, 1000, 1017, 1500, 1700, 1940, 3983, 1983, 3990}; // ms 712 vector<int32_t> audioVals = {199, 199, 199, 149, 149, 149, 99, 149, 149, 99, 149, 149, 99, 149, 99, 99, 149, 99, 713 49, 49, 99, 149, 99, 49, 49}; 714 vector<int32_t> videoVals = {240, 240, 240, 180, 180, 180, 120, 180, 180, 120, 180, 180, 120, 180, 120, 120, 180, 715 120, 60, 60, 120, 180, 120, 60, 60}; 716 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 717 ASSERT_NE(sharedMem_, nullptr); 718 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 719 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 720 ret_ = demuxer_->SeekToTime(*toPts, *mode); 721 if (ret_ != AV_ERR_OK) { 722 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 723 continue; 724 } 725 ReadData(); 726 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 727 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 728 ASSERT_EQ(frames_[0], videoVals[numbers_]); 729 ASSERT_EQ(frames_[1], audioVals[numbers_]); 730 numbers_ += 1; 731 RemoveValue(); 732 selectedTrackIds_.clear(); 733 } 734 } 735 } 736 737 /** 738 * @tc.name: Demuxer_SeekToTime_2060 739 * @tc.desc: seek to the specified time 740 * @tc.type: FUNC 741 */ 742 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2060, TestSize.Level1) 743 { 744 InitResource(g_tsUri, URI); 745 ASSERT_TRUE(initStatus_); 746 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 747 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 748 list<int64_t> toPtsList = {0, 3480, 3640, 3320, 3000, 3100, 4120, 5520}; // ms 749 vector<int32_t> videoVals = {103, 103, 103, 15, 15, 15, 11, 11, 11, 19, 19, 19, 27, 27, 27, 24, 25, 25, 1, 1, 1}; 750 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 751 ASSERT_NE(sharedMem_, nullptr); 752 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 753 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 754 ret_ = demuxer_->SeekToTime(*toPts, *mode); 755 if (ret_ != AV_ERR_OK) { 756 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 757 continue; 758 } 759 ReadData(); 760 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 761 ASSERT_EQ(frames_[0], videoVals[numbers_]); 762 numbers_ += 1; 763 RemoveValue(); 764 selectedTrackIds_.clear(); 765 } 766 } 767 } 768 769 /** 770 * @tc.name: Demuxer_SeekToTime_2070 771 * @tc.desc: seek to the specified time 772 * @tc.type: FUNC 773 */ 774 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2070, TestSize.Level1) 775 { 776 InitResource(g_aacUri, URI); 777 ASSERT_TRUE(initStatus_); 778 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 779 list<int64_t> toPtsList = {0, 10240, 10230, 10220, 30000, 30010}; // ms 780 vector<int32_t> audioVals = {1293, 1293, 1293, 852, 852, 852, 852, 853, 853, 852, 853, 853, 2, 2, 2, 1, 1, 1}; 781 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 782 ASSERT_NE(sharedMem_, nullptr); 783 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 784 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 785 ret_ = demuxer_->SeekToTime(*toPts, *mode); 786 if (ret_ != AV_ERR_OK) { 787 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 788 continue; 789 } 790 ReadData(); 791 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 792 ASSERT_EQ(frames_[0], audioVals[numbers_]); 793 numbers_ += 1; 794 RemoveValue(); 795 selectedTrackIds_.clear(); 796 } 797 } 798 } 799 800 /** 801 * @tc.name: Demuxer_SeekToTime_2080 802 * @tc.desc: seek to the specified time 803 * @tc.type: FUNC 804 */ 805 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2080, TestSize.Level1) 806 { 807 InitResource(g_flacUri, URI); 808 ASSERT_TRUE(initStatus_); 809 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 810 list<int64_t> toPtsList = {0, 3072, 4031, 4035, 29952, 29953}; // ms 811 vector<int32_t> audioVals = {313, 313, 313, 281, 281, 281, 271, 271, 271, 270, 270, 270, 1, 1, 1, 2, 2, 2}; 812 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 813 ASSERT_NE(sharedMem_, nullptr); 814 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 815 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 816 ret_ = demuxer_->SeekToTime(*toPts, *mode); 817 if (ret_ != AV_ERR_OK) { 818 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 819 continue; 820 } 821 ReadData(); 822 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 823 ASSERT_EQ(frames_[0], audioVals[numbers_]); 824 numbers_ += 1; 825 RemoveValue(); 826 selectedTrackIds_.clear(); 827 } 828 } 829 } 830 831 /** 832 * @tc.name: Demuxer_SeekToTime_2090 833 * @tc.desc: seek to the specified time 834 * @tc.type: FUNC 835 */ 836 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2090, TestSize.Level1) 837 { 838 InitResource(g_m4aUri, URI); 839 ASSERT_TRUE(initStatus_); 840 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 841 list<int64_t> toPtsList = {0, 14592, 15297, 15290, 29994, 29998}; // ms 842 vector<int32_t> audioVals = {1407, 1407, 1407, 723, 723, 723, 689, 690, 690, 690, 691, 691, 2, 2, 2, 1, 1, 1}; 843 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 844 ASSERT_NE(sharedMem_, nullptr); 845 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 846 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 847 ret_ = demuxer_->SeekToTime(*toPts, *mode); 848 if (ret_ != AV_ERR_OK) { 849 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 850 continue; 851 } 852 ReadData(); 853 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 854 ASSERT_EQ(frames_[0], audioVals[numbers_]); 855 numbers_ += 1; 856 RemoveValue(); 857 selectedTrackIds_.clear(); 858 } 859 } 860 } 861 862 /** 863 * @tc.name: Demuxer_SeekToTime_2100 864 * @tc.desc: seek to the specified time 865 * @tc.type: FUNC 866 */ 867 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2100, TestSize.Level1) 868 { 869 InitResource(g_mp3Uri, URI); 870 ASSERT_TRUE(initStatus_); 871 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 872 list<int64_t> toPtsList = {0, 4128, 11980, 11990, 30000, 30010}; // ms 873 vector<int32_t> audioVals = {1251, 1251, 1251, 1077, 1078, 1078, 750, 751, 751, 750, 751, 751, 1, 1, 1, 1, 1, 1}; 874 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 875 ASSERT_NE(sharedMem_, nullptr); 876 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 877 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 878 ret_ = demuxer_->SeekToTime(*toPts, *mode); 879 if (ret_ != AV_ERR_OK) { 880 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 881 continue; 882 } 883 ReadData(); 884 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 885 ASSERT_EQ(frames_[0], audioVals[numbers_]); 886 numbers_ += 1; 887 RemoveValue(); 888 selectedTrackIds_.clear(); 889 } 890 } 891 } 892 893 /** 894 * @tc.name: Demuxer_SeekToTime_2110 895 * @tc.desc: seek to the specified time 896 * @tc.type: FUNC 897 */ 898 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2110, TestSize.Level1) 899 { 900 InitResource(g_oggUri, URI); 901 ASSERT_TRUE(initStatus_); 902 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 903 list<int64_t> toPtsList = {0, 5868, 5548, 5292, 29992, 29999}; // ms 904 vector<int32_t> audioVals = {1598, 1598, 1598, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 1357, 46, 46, 905 46, 46, 46, 46}; 906 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 907 ASSERT_NE(sharedMem_, nullptr); 908 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 909 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 910 ret_ = demuxer_->SeekToTime(*toPts, *mode); 911 if (ret_ != AV_ERR_OK) { 912 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 913 continue; 914 } 915 ReadData(); 916 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 917 ASSERT_EQ(frames_[0], audioVals[numbers_]); 918 numbers_ += 1; 919 RemoveValue(); 920 selectedTrackIds_.clear(); 921 } 922 } 923 } 924 925 /** 926 * @tc.name: Demuxer_SeekToTime_2120 927 * @tc.desc: seek to the specified time 928 * @tc.type: FUNC 929 */ 930 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2120, TestSize.Level1) 931 { 932 InitResource(g_wavUri, URI); 933 ASSERT_TRUE(initStatus_); 934 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 935 list<int64_t> toPtsList = {0, 8576, 8566, 8578, 29994, 30000}; // ms 936 vector<int32_t> audioVals = {704, 704, 704, 503, 503, 503, 504, 504, 504, 503, 503, 503, 2, 2, 2, 1, 1, 1}; 937 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 938 ASSERT_NE(sharedMem_, nullptr); 939 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 940 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 941 ret_ = demuxer_->SeekToTime(*toPts, *mode); 942 if (ret_ != AV_ERR_OK) { 943 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 944 continue; 945 } 946 ReadData(); 947 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 948 ASSERT_EQ(frames_[0], audioVals[numbers_]); 949 numbers_ += 1; 950 RemoveValue(); 951 selectedTrackIds_.clear(); 952 } 953 } 954 } 955 956 /** 957 * @tc.name: Demuxer_SeekToTime_2130 958 * @tc.desc: seek to the specified time 959 * @tc.type: FUNC 960 */ 961 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2130, TestSize.Level1) 962 { 963 InitResource(g_amrUri, URI); 964 ASSERT_TRUE(initStatus_); 965 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 966 list<int64_t> toPtsList = {0, 8560, 8550, 8570, 30000, 30900}; // ms 967 vector<int32_t> audioVals = {1501, 1501, 1501, 1073, 1073, 1073, 1073, 1074, 1074, 1072, 1073, 1073, 968 1, 1, 1, 1, 1, 1}; 969 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 970 ASSERT_NE(sharedMem_, nullptr); 971 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 972 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 973 ret_ = demuxer_->SeekToTime(*toPts, *mode); 974 if (ret_ != AV_ERR_OK) { 975 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 976 continue; 977 } 978 ReadData(); 979 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 980 ASSERT_EQ(frames_[0], audioVals[numbers_]); 981 numbers_ += 1; 982 RemoveValue(); 983 selectedTrackIds_.clear(); 984 } 985 } 986 } 987 988 /** 989 * @tc.name: Demuxer_SeekToTime_2140 990 * @tc.desc: seek to the specified time 991 * @tc.type: FUNC 992 */ 993 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2140, TestSize.Level1) 994 { 995 InitResource(g_amrUri2, URI); 996 ASSERT_TRUE(initStatus_); 997 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 998 list<int64_t> toPtsList = {0, 11920, 11910, 11930, 29980, 30800}; // ms 999 vector<int32_t> audioVals = {1500, 1500, 1500, 904, 904, 904, 904, 905, 905, 903, 904, 904, 1000 1, 1, 1, 1, 1, 1}; 1001 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1002 ASSERT_NE(sharedMem_, nullptr); 1003 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1004 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1005 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1006 if (ret_ != AV_ERR_OK) { 1007 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1008 continue; 1009 } 1010 ReadData(); 1011 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 1012 ASSERT_EQ(frames_[0], audioVals[numbers_]); 1013 numbers_ += 1; 1014 RemoveValue(); 1015 selectedTrackIds_.clear(); 1016 } 1017 } 1018 } 1019 1020 /** 1021 * @tc.name: Demuxer_SeekToTime_2150 1022 * @tc.desc: seek to the specified time(audioVivid m4a) 1023 * @tc.type: FUNC 1024 */ 1025 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2150, TestSize.Level1) 1026 { 1027 InitResource(g_audioVividUri, URI); 1028 ASSERT_TRUE(initStatus_); 1029 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1030 list<int64_t> toPtsList = {0, 10000, 8000, 12300, 25000, 29000, 30800, 33000}; // ms 1031 vector<int32_t> audioVals = {1380, 1380, 1380, 949, 950, 950, 1035, 1036, 1036, 850, 851, 851, 303, 304, 304, 1032 131, 132, 132, 53, 54, 54}; 1033 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1034 ASSERT_NE(sharedMem_, nullptr); 1035 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1036 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1037 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1038 if (ret_ != AV_ERR_OK) { 1039 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1040 continue; 1041 } 1042 ReadData(); 1043 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 1044 ASSERT_EQ(frames_[0], audioVals[numbers_]); 1045 numbers_ += 1; 1046 RemoveValue(); 1047 selectedTrackIds_.clear(); 1048 } 1049 } 1050 ASSERT_NE(demuxer_->SelectTrackByID(3), AV_ERR_OK); 1051 ASSERT_NE(demuxer_->SelectTrackByID(-1), AV_ERR_OK); 1052 ASSERT_EQ(demuxer_->UnselectTrackByID(3), AV_ERR_OK); 1053 ASSERT_EQ(demuxer_->UnselectTrackByID(-1), AV_ERR_OK); 1054 ASSERT_EQ(demuxer_->UnselectTrackByID(0), AV_ERR_OK); 1055 } 1056 1057 /** 1058 * @tc.name: Demuxer_SeekToTime_21501 1059 * @tc.desc: seek to the file duration(audioVivid m4a) 1060 * @tc.type: FUNC 1061 */ 1062 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_21501, TestSize.Level1) 1063 { 1064 InitResource(g_audioVividUri, URI); 1065 ASSERT_TRUE(initStatus_); 1066 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1067 list<int64_t> toPtsList = {32044}; // file duration ms 1068 vector<int32_t> audioVals = {1, 1, 1}; 1069 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1070 ASSERT_NE(sharedMem_, nullptr); 1071 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1072 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1073 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1074 ASSERT_EQ(ret_, AV_ERR_OK); 1075 ReadData(); 1076 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 1077 ASSERT_EQ(frames_[0], audioVals[numbers_]); 1078 numbers_ += 1; 1079 RemoveValue(); 1080 selectedTrackIds_.clear(); 1081 } 1082 } 1083 } 1084 1085 /** 1086 * @tc.name: Demuxer_SeekToTime_1195 1087 * @tc.desc: seek to the specified time(two sound track mp4 uri) 1088 * @tc.type: FUNC 1089 */ 1090 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1195, TestSize.Level1) 1091 { 1092 string path = TEST_URI_PATH + string("avcc_aac_mp3.mp4"); 1093 InitResource(path, URI); 1094 ASSERT_TRUE(initStatus_); 1095 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1096 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1097 ASSERT_EQ(demuxer_->SelectTrackByID(2), AV_ERR_OK); 1098 list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000}; // ms 1099 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602, 102, 102}; 1100 vector<int32_t> audioVals = {433, 433, 433, 74, 254, 254, 74, 254, 74, 253, 433, 433, 75, 75}; 1101 vector<int32_t> audioVals2 = {417, 417, 417, 71, 245, 245, 71, 245, 71, 244, 417, 417, 72, 72}; 1102 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1103 ASSERT_NE(sharedMem_, nullptr); 1104 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1105 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1106 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1107 if (ret_ != AV_ERR_OK) { 1108 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1109 continue; 1110 } 1111 ReadData(); 1112 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 1113 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 1114 printf("time = %" PRId64 " | frames_[2]=%d | kFrames[2]=%d\n", *toPts, frames_[2], keyFrames_[2]); 1115 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1116 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1117 ASSERT_EQ(frames_[2], audioVals2[numbers_]); 1118 numbers_ += 1; 1119 RemoveValue(); 1120 selectedTrackIds_.clear(); 1121 } 1122 } 1123 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1124 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1125 } 1126 1127 /** 1128 * @tc.name: Demuxer_ReadSample_1223 1129 * @tc.desc: copy current sample to buffer(ape) 1130 * @tc.type: FUNC 1131 */ 1132 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1223, TestSize.Level1) 1133 { 1134 ReadSample(g_apeUri, URI); 1135 for (auto idx : selectedTrackIds_) { 1136 ASSERT_EQ(frames_[idx], infoMap["ape"]["frames"][idx]); 1137 ASSERT_EQ(keyFrames_[idx], infoMap["ape"]["kFrames"][idx]); 1138 } 1139 RemoveValue(); 1140 selectedTrackIds_.clear(); 1141 } 1142 1143 /** 1144 * @tc.name: Demuxer_SeekToTime_1225 1145 * @tc.desc: seek to the specified time(two sound track ape local) 1146 * @tc.type: FUNC 1147 */ 1148 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1225, TestSize.Level1) 1149 { 1150 InitResource(g_apeUri, URI); 1151 ASSERT_TRUE(initStatus_); 1152 ASSERT_TRUE(SetInitValue()); 1153 for (auto idx : selectedTrackIds_) { 1154 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1155 } 1156 list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000}; // ms 1157 vector<int32_t> audioVals = {7, 7, 7, 4, 5, 5, 2, 3, 3, 5, 6, 6, 1, 2, 2}; 1158 1159 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1160 ASSERT_NE(sharedMem_, nullptr); 1161 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1162 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1163 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1164 if (ret_ != AV_ERR_OK) { 1165 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1166 continue; 1167 } 1168 ReadData(); 1169 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 1170 ASSERT_EQ(frames_[0], audioVals[numbers_]); 1171 numbers_ += 1; 1172 RemoveValue(); 1173 selectedTrackIds_.clear(); 1174 } 1175 } 1176 ASSERT_NE(demuxer_->SeekToTime(12000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1177 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1178 } 1179 1180 /** 1181 * @tc.name: Demuxer_SeekToTime_1205 1182 * @tc.desc: seek to the specified time(h264 flv uri) 1183 * @tc.type: FUNC 1184 */ 1185 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1205, TestSize.Level1) 1186 { 1187 InitResource(g_flvUri, URI); 1188 ASSERT_TRUE(initStatus_); 1189 ASSERT_TRUE(SetInitValue()); 1190 for (auto idx : selectedTrackIds_) { 1191 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1192 } 1193 list<int64_t> toPtsList = {0, 1500, 1000, 1740, 1970, 2100}; // ms 1194 vector<int32_t> videoVals = {76, 76, 76, 0, 76, 0, 0, 76, 76, 0, 76, 0, 0, 76, 0, 0, 76, 0}; 1195 vector<int32_t> audioVals = {107, 107, 107, 0, 107, 0, 0, 107, 107, 0, 107, 0, 0, 107, 0, 0, 107, 0}; 1196 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1197 ASSERT_NE(sharedMem_, nullptr); 1198 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1199 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1200 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1201 if (ret_ != AV_ERR_OK) { 1202 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1203 continue; 1204 } 1205 ReadData(); 1206 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1207 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1208 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1209 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1210 numbers_ += 1; 1211 RemoveValue(); 1212 selectedTrackIds_.clear(); 1213 } 1214 } 1215 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1216 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1217 } 1218 1219 /** 1220 * @tc.name: Demuxer_SeekToTime_1230 1221 * @tc.desc: seek to the specified time(h264 fmp4 uri) 1222 * @tc.type: FUNC 1223 */ 1224 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1230, TestSize.Level1) 1225 { 1226 InitResource(g_fmp4AvcUri, URI); 1227 ASSERT_TRUE(initStatus_); 1228 ASSERT_TRUE(SetInitValue()); 1229 for (auto idx : selectedTrackIds_) { 1230 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1231 } 1232 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1233 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1234 vector<int32_t> audioVals = {433, 433, 433, 74, 254, 254, 74, 254, 74, 253, 433, 433}; 1235 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1236 ASSERT_NE(sharedMem_, nullptr); 1237 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1238 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1239 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1240 if (ret_ != AV_ERR_OK) { 1241 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1242 continue; 1243 } 1244 ReadData(); 1245 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1246 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1247 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1248 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1249 numbers_ += 1; 1250 RemoveValue(); 1251 selectedTrackIds_.clear(); 1252 } 1253 } 1254 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1255 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1256 } 1257 1258 /** 1259 * @tc.name: Demuxer_SeekToTime_1240 1260 * @tc.desc: seek to the specified time(fmp4 m4v uri) 1261 * @tc.type: FUNC 1262 */ 1263 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1240, TestSize.Level1) 1264 { 1265 InitResource(g_fmp4m4vUri, URI); 1266 ASSERT_TRUE(initStatus_); 1267 ASSERT_TRUE(SetInitValue()); 1268 for (auto idx : selectedTrackIds_) { 1269 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1270 } 1271 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1272 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1273 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1274 ASSERT_NE(sharedMem_, nullptr); 1275 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1276 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1277 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1278 if (ret_ != AV_ERR_OK) { 1279 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1280 continue; 1281 } 1282 ReadData(); 1283 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1284 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1285 numbers_ += 1; 1286 RemoveValue(); 1287 selectedTrackIds_.clear(); 1288 } 1289 } 1290 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1291 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1292 } 1293 1294 /** 1295 * @tc.name: Demuxer_SeekToTime_1241 1296 * @tc.desc: seek to the specified time(fmp4 m4a uri) 1297 * @tc.type: FUNC 1298 */ 1299 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1241, TestSize.Level1) 1300 { 1301 InitResource(g_fmp4m4aUri, URI); 1302 ASSERT_TRUE(initStatus_); 1303 ASSERT_TRUE(SetInitValue()); 1304 for (auto idx : selectedTrackIds_) { 1305 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1306 } 1307 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1308 vector<int32_t> audioVals = {433, 433, 433, 239, 240, 240, 131, 132, 132, 347, 348, 348}; 1309 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1310 ASSERT_NE(sharedMem_, nullptr); 1311 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1312 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1313 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1314 if (ret_ != AV_ERR_OK) { 1315 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1316 continue; 1317 } 1318 ReadData(); 1319 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1320 ASSERT_EQ(frames_[0], audioVals[numbers_]); 1321 numbers_ += 1; 1322 RemoveValue(); 1323 selectedTrackIds_.clear(); 1324 } 1325 } 1326 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1327 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1328 } 1329 1330 /** 1331 * @tc.name: Demuxer_ReadSample_1410 1332 * @tc.desc: copy current sample to buffer(h264 hls uri) 1333 * @tc.type: FUNC 1334 */ 1335 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1410, TestSize.Level1) 1336 { 1337 if (g_hls.find(TEST_URI_PATH2) == std::string::npos) { 1338 InitResource(g_hls, URI); 1339 ASSERT_TRUE(initStatus_); 1340 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1341 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1342 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1343 ASSERT_NE(sharedMem_, nullptr); 1344 ASSERT_TRUE(SetInitValue()); 1345 while (!isEOS(eosFlag_)) { 1346 for (auto idx : selectedTrackIds_) { 1347 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1348 CountFrames(idx); 1349 } 1350 } 1351 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1352 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1353 ASSERT_EQ(frames_[0], 602); 1354 ASSERT_EQ(frames_[1], 433); 1355 ASSERT_EQ(keyFrames_[0], 3); 1356 ASSERT_EQ(keyFrames_[1], 433); 1357 RemoveValue(); 1358 } 1359 } 1360 1361 /** 1362 * @tc.name: Demuxer_SeekToTime_1411 1363 * @tc.desc: seek to the specified time(h264 hls uri) 1364 * @tc.type: FUNC 1365 */ 1366 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1411, TestSize.Level1) 1367 { 1368 if (g_hls.find(TEST_URI_PATH2) == std::string::npos) { 1369 InitResource(g_hls, URI); 1370 ASSERT_TRUE(initStatus_); 1371 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1372 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1373 list<int64_t> toPtsList = {0, 4500, 7000, 2000, 10000}; // ms 1374 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602, 102, 102}; 1375 vector<int32_t> audioVals = {433, 433, 433, 74, 254, 254, 74, 254, 74, 253, 433, 433, 75, 75}; 1376 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1377 ASSERT_NE(sharedMem_, nullptr); 1378 SeekTest(toPtsList, seekModes, {videoVals, audioVals}); 1379 ASSERT_TRUE(seekTestFlag_); 1380 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1381 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1382 } 1383 } 1384 1385 /** 1386 * @tc.name: Demuxer_ReadSample_3001 1387 * @tc.desc: copy current sample to buffer(srt) 1388 * @tc.type: FUNC 1389 */ 1390 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_3001, TestSize.Level1) 1391 { 1392 InitResource(g_srt, URI); 1393 ASSERT_TRUE(initStatus_); 1394 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1395 1396 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1397 ASSERT_NE(sharedMem_, nullptr); 1398 ASSERT_TRUE(SetInitValue()); 1399 while (!isEOS(eosFlag_)) { 1400 for (auto idx : selectedTrackIds_) { 1401 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1402 CountFrames(idx); 1403 } 1404 } 1405 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1406 ASSERT_EQ(frames_[0], 5); 1407 RemoveValue(); 1408 } 1409 1410 /** 1411 * @tc.name: Demuxer_SeekToTime_3001 1412 * @tc.desc: seek to the specified time(srt) 1413 * @tc.type: FUNC 1414 */ 1415 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_3001, TestSize.Level1) 1416 { 1417 InitResource(g_srt, URI); 1418 ASSERT_TRUE(initStatus_); 1419 ASSERT_TRUE(SetInitValue()); 1420 for (auto idx : selectedTrackIds_) { 1421 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1422 } 1423 list<int64_t> toPtsList = {160, 2000, 4000, 7000}; // ms 1424 vector<int32_t> subVals = {5, 5, 5, 5, 5, 5, 4, 4, 4, 2, 2, 2}; 1425 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1426 ASSERT_NE(sharedMem_, nullptr); 1427 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1428 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1429 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1430 if (ret_ != AV_ERR_OK) { 1431 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1432 continue; 1433 } 1434 ReadData(); 1435 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1436 ASSERT_EQ(frames_[0], subVals[numbers_]); 1437 numbers_ += 1; 1438 RemoveValue(); 1439 selectedTrackIds_.clear(); 1440 } 1441 } 1442 } 1443 1444 /** 1445 * @tc.name: Demuxer_ReadSample_1611 1446 * @tc.desc: copy current sample to buffer(mp4 vvc) 1447 * @tc.type: FUNC 1448 */ 1449 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1611, TestSize.Level1) 1450 { 1451 if (access(g_mp4VvcPath.c_str(), F_OK) == 0) { 1452 InitResource(g_mp4VvcUri, URI); 1453 ASSERT_TRUE(initStatus_); 1454 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1455 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1456 ASSERT_NE(sharedMem_, nullptr); 1457 ASSERT_TRUE(SetInitValue()); 1458 uint32_t idx = 0; 1459 while (!isEOS(eosFlag_)) { 1460 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1461 CountFrames(idx); 1462 } 1463 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1464 ASSERT_EQ(frames_[0], 600); 1465 ASSERT_EQ(keyFrames_[0], 10); 1466 RemoveValue(); 1467 } 1468 } 1469 1470 /** 1471 * @tc.name: Demuxer_SeekToTime_1611 1472 * @tc.desc: seek to the specified time(mpv vvc uri) 1473 * @tc.type: FUNC 1474 */ 1475 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1611, TestSize.Level1) 1476 { 1477 if (access(g_mp4VvcPath.c_str(), F_OK) == 0) { 1478 InitResource(g_mp4VvcUri, URI); 1479 ASSERT_TRUE(initStatus_); 1480 ASSERT_TRUE(SetInitValue()); 1481 for (auto idx : selectedTrackIds_) { 1482 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1483 } 1484 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1485 vector<int32_t> audioVals = {433, 433, 433, 240, 240, 240, 132, 132, 132, 348, 348, 348}; 1486 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1487 ASSERT_NE(sharedMem_, nullptr); 1488 SeekTest(toPtsList, seekModes, {audioVals}); 1489 ASSERT_TRUE(seekTestFlag_); 1490 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1491 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1492 } 1493 } 1494 } // namespace 1495