1 /* 2 * Copyright (C) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <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 #define URI false 31 32 using namespace OHOS; 33 using namespace OHOS::Media; 34 using namespace OHOS::MediaAVCodec; 35 using namespace testing::ext; 36 using namespace std; 37 38 namespace { 39 unique_ptr<FileServerDemo> server = nullptr; 40 static const string TEST_FILE_PATH = "/data/test/media/"; 41 static const string TEST_URI_PATH = "http://127.0.0.1:46666/"; 42 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so"; 43 list<SeekMode> seekModes = {SeekMode::SEEK_NEXT_SYNC, SeekMode::SEEK_PREVIOUS_SYNC, 44 SeekMode::SEEK_CLOSEST_SYNC}; 45 string g_tsMpeg4Path = TEST_FILE_PATH + string("test_mpeg4_Gop25_4sec.ts"); 46 string g_tsMpeg4Uri = TEST_URI_PATH + string("test_mpeg4_Gop25_4sec.ts"); 47 string g_h264aacPath = TEST_FILE_PATH + string("h264_aac.mov"); 48 string g_h264mp3Path = TEST_FILE_PATH + string("h264_mp3.mov"); 49 string g_h264vorPath = TEST_FILE_PATH + string("h264_vorbis.mov"); 50 string g_mpg4mp2Path = TEST_FILE_PATH + string("MPEG4_mp2.mov"); 51 string g_h264aacUri = TEST_URI_PATH + string("h264_aac.mov"); 52 string g_h264mp3Uri = TEST_URI_PATH + string("h264_mp3.mov"); 53 string g_h264vorUri = TEST_URI_PATH + string("h264_vorbis.mov"); 54 string g_mpg4mp2Uri = TEST_URI_PATH + string("MPEG4_mp2.mov"); 55 string g_aviAvcMp3Path = TEST_FILE_PATH + string("h264_mp3.avi"); 56 string g_aviAvcMp3Uri = TEST_URI_PATH + string("h264_mp3.avi"); 57 string g_avi263AacPath = TEST_FILE_PATH + string("test_263_aac_B_Gop25_4sec_cover.avi"); 58 string g_avi263AacUri = TEST_URI_PATH + string("test_263_aac_B_Gop25_4sec_cover.avi"); 59 string g_aviMpeg2Mp2Path = TEST_FILE_PATH + string("test_mpeg2_mp2_B_Gop25_4sec_cover.avi"); 60 string g_aviMpeg2Mp2Uri = TEST_URI_PATH + string("test_mpeg2_mp2_B_Gop25_4sec_cover.avi"); 61 string g_aviMpeg4Mp3Path = TEST_FILE_PATH + string("test_mpeg4_mp3_B_Gop25_4sec_cover.avi"); 62 string g_aviMpeg4Mp3Uri = TEST_URI_PATH + string("test_mpeg4_mp3_B_Gop25_4sec_cover.avi"); 63 string g_aviMpeg4PcmPath = TEST_FILE_PATH + string("mpeg4_pcm.avi"); 64 string g_aviMpeg4PcmUri = TEST_URI_PATH + string("mpeg4_pcm.avi"); 65 string g_mpg4mp4Path = TEST_FILE_PATH + string("MPEG4.mp4"); 66 string g_mpg4mp4Uri = TEST_URI_PATH + string("MPEG4.mp4"); 67 string g_mp4AvcAacAuxlPath = TEST_FILE_PATH + string("muxer_auxl_265_264_aac.mp4"); 68 string g_mp4AvcAacAuxlUri = TEST_URI_PATH + string("muxer_auxl_265_264_aac.mp4"); 69 } // namespace 70 71 /**********************************demuxer fd**************************************/ 72 namespace { 73 /** 74 * @tc.name: Demuxer_ReadSample_1075 75 * @tc.desc: copy current sample to buffer 76 * @tc.type: FUNC 77 */ 78 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_1075, TestSize.Level1) 79 { 80 InitResource(g_tsMpeg4Path, LOCAL); 81 ASSERT_TRUE(initStatus_); 82 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 83 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 84 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 85 ASSERT_NE(sharedMem_, nullptr); 86 ASSERT_TRUE(SetInitValue()); 87 while (!isEOS(eosFlag_)) { 88 for (auto idx : selectedTrackIds_) { 89 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 90 CountFrames(idx); 91 } 92 } 93 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 94 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 95 ASSERT_EQ(frames_[0], 103); 96 ASSERT_EQ(frames_[1], 155); 97 ASSERT_EQ(keyFrames_[0], 9); 98 ASSERT_EQ(keyFrames_[1], 155); 99 RemoveValue(); 100 } 101 102 /** 103 * @tc.name: Demuxer_ReadSample_2075 104 * @tc.desc: copy current sample to buffer 105 * @tc.type: FUNC 106 */ 107 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2075, TestSize.Level1) 108 { 109 InitResource(g_tsMpeg4Uri, URI); 110 ASSERT_TRUE(initStatus_); 111 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 112 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 113 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 114 ASSERT_NE(sharedMem_, nullptr); 115 ASSERT_TRUE(SetInitValue()); 116 while (!isEOS(eosFlag_)) { 117 for (auto idx : selectedTrackIds_) { 118 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 119 CountFrames(idx); 120 } 121 } 122 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 123 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 124 ASSERT_EQ(frames_[0], 103); 125 ASSERT_EQ(frames_[1], 155); 126 ASSERT_EQ(keyFrames_[0], 9); 127 ASSERT_EQ(keyFrames_[1], 155); 128 RemoveValue(); 129 } 130 131 /** 132 * @tc.name: Demuxer_ReadSample_2222 133 * @tc.desc: copy current sample to buffer, local 134 * @tc.type: FUNC 135 */ 136 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2222, TestSize.Level1) 137 { 138 InitResource(g_aviAvcMp3Path, LOCAL); 139 ASSERT_TRUE(initStatus_); 140 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 141 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 142 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 143 ASSERT_NE(sharedMem_, nullptr); 144 ASSERT_TRUE(SetInitValue()); 145 while (!isEOS(eosFlag_)) { 146 for (auto idx : selectedTrackIds_) { 147 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 148 CountFrames(idx); 149 } 150 } 151 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 152 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 153 ASSERT_EQ(frames_[0], 602); 154 ASSERT_EQ(frames_[1], 386); 155 ASSERT_EQ(keyFrames_[0], 3); 156 ASSERT_EQ(keyFrames_[1], 386); 157 RemoveValue(); 158 } 159 160 /** 161 * @tc.name: Demuxer_ReadSample_2232 162 * @tc.desc: copy current sample to buffer, uri 163 * @tc.type: FUNC 164 */ 165 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2232, TestSize.Level1) 166 { 167 InitResource(g_aviAvcMp3Uri, URI); 168 ASSERT_TRUE(initStatus_); 169 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 170 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 171 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 172 ASSERT_NE(sharedMem_, nullptr); 173 ASSERT_TRUE(SetInitValue()); 174 while (!isEOS(eosFlag_)) { 175 for (auto idx : selectedTrackIds_) { 176 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 177 CountFrames(idx); 178 } 179 } 180 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 181 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 182 ASSERT_EQ(frames_[0], 602); 183 ASSERT_EQ(frames_[1], 386); 184 ASSERT_EQ(keyFrames_[0], 3); 185 ASSERT_EQ(keyFrames_[1], 386); 186 RemoveValue(); 187 } 188 189 /** 190 * @tc.name: Demuxer_ReadSample_2226 191 * @tc.desc: copy current sample to buffer, local 192 * @tc.type: FUNC 193 */ 194 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2226, TestSize.Level1) 195 { 196 InitResource(g_aviMpeg2Mp2Path, LOCAL); 197 ASSERT_TRUE(initStatus_); 198 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 199 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 200 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 201 ASSERT_NE(sharedMem_, nullptr); 202 ASSERT_TRUE(SetInitValue()); 203 while (!isEOS(eosFlag_)) { 204 for (auto idx : selectedTrackIds_) { 205 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 206 CountFrames(idx); 207 } 208 } 209 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 210 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 211 ASSERT_EQ(frames_[0], 103); 212 ASSERT_EQ(frames_[1], 155); 213 ASSERT_EQ(keyFrames_[0], 9); 214 ASSERT_EQ(keyFrames_[1], 155); 215 RemoveValue(); 216 } 217 218 /** 219 * @tc.name: Demuxer_ReadSample_2236 220 * @tc.desc: copy current sample to buffer, uri 221 * @tc.type: FUNC 222 */ 223 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2236, TestSize.Level1) 224 { 225 InitResource(g_aviMpeg2Mp2Uri, URI); 226 ASSERT_TRUE(initStatus_); 227 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 228 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 229 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 230 ASSERT_NE(sharedMem_, nullptr); 231 ASSERT_TRUE(SetInitValue()); 232 while (!isEOS(eosFlag_)) { 233 for (auto idx : selectedTrackIds_) { 234 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 235 CountFrames(idx); 236 } 237 } 238 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 239 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 240 ASSERT_EQ(frames_[0], 103); 241 ASSERT_EQ(frames_[1], 155); 242 ASSERT_EQ(keyFrames_[0], 9); 243 ASSERT_EQ(keyFrames_[1], 155); 244 RemoveValue(); 245 } 246 247 /** 248 * @tc.name: Demuxer_ReadSample_2227 249 * @tc.desc: copy current sample to buffer, local 250 * @tc.type: FUNC 251 */ 252 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2227, TestSize.Level1) 253 { 254 InitResource(g_aviMpeg4Mp3Path, LOCAL); 255 ASSERT_TRUE(initStatus_); 256 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 257 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 258 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 259 ASSERT_NE(sharedMem_, nullptr); 260 ASSERT_TRUE(SetInitValue()); 261 while (!isEOS(eosFlag_)) { 262 for (auto idx : selectedTrackIds_) { 263 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 264 CountFrames(idx); 265 } 266 } 267 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 268 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 269 ASSERT_EQ(frames_[0], 103); 270 ASSERT_EQ(frames_[1], 156); 271 ASSERT_EQ(keyFrames_[0], 9); 272 ASSERT_EQ(keyFrames_[1], 156); 273 RemoveValue(); 274 } 275 276 /** 277 * @tc.name: Demuxer_ReadSample_2237 278 * @tc.desc: copy current sample to buffer, uri 279 * @tc.type: FUNC 280 */ 281 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2237, TestSize.Level1) 282 { 283 InitResource(g_aviMpeg4Mp3Uri, URI); 284 ASSERT_TRUE(initStatus_); 285 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 286 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 287 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 288 ASSERT_NE(sharedMem_, nullptr); 289 ASSERT_TRUE(SetInitValue()); 290 while (!isEOS(eosFlag_)) { 291 for (auto idx : selectedTrackIds_) { 292 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 293 CountFrames(idx); 294 } 295 } 296 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 297 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 298 ASSERT_EQ(frames_[0], 103); 299 ASSERT_EQ(frames_[1], 156); 300 ASSERT_EQ(keyFrames_[0], 9); 301 ASSERT_EQ(keyFrames_[1], 156); 302 RemoveValue(); 303 } 304 305 /** 306 * @tc.name: Demuxer_ReadSample_2229 307 * @tc.desc: copy current sample to buffer, local 308 * @tc.type: FUNC 309 */ 310 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2229, TestSize.Level1) 311 { 312 InitResource(g_aviMpeg4PcmPath, LOCAL); 313 ASSERT_TRUE(initStatus_); 314 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 315 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 316 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 317 ASSERT_NE(sharedMem_, nullptr); 318 ASSERT_TRUE(SetInitValue()); 319 while (!isEOS(eosFlag_)) { 320 for (auto idx : selectedTrackIds_) { 321 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 322 CountFrames(idx); 323 } 324 } 325 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 326 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 327 ASSERT_EQ(frames_[0], 604); 328 ASSERT_EQ(frames_[1], 433); 329 ASSERT_EQ(keyFrames_[0], 51); 330 ASSERT_EQ(keyFrames_[1], 433); 331 RemoveValue(); 332 } 333 334 /** 335 * @tc.name: Demuxer_ReadSample_2239 336 * @tc.desc: copy current sample to buffer, uri 337 * @tc.type: FUNC 338 */ 339 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2239, TestSize.Level1) 340 { 341 InitResource(g_aviMpeg4PcmUri, URI); 342 ASSERT_TRUE(initStatus_); 343 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 344 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 345 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 346 ASSERT_NE(sharedMem_, nullptr); 347 ASSERT_TRUE(SetInitValue()); 348 while (!isEOS(eosFlag_)) { 349 for (auto idx : selectedTrackIds_) { 350 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 351 CountFrames(idx); 352 } 353 } 354 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 355 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 356 ASSERT_EQ(frames_[0], 604); 357 ASSERT_EQ(frames_[1], 433); 358 ASSERT_EQ(keyFrames_[0], 51); 359 ASSERT_EQ(keyFrames_[1], 433); 360 RemoveValue(); 361 } 362 363 /** 364 * @tc.name: Demuxer_ReadSample_2230 365 * @tc.desc: copy current sample to buffer, local 366 * @tc.type: FUNC 367 */ 368 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2230, TestSize.Level1) 369 { 370 InitResource(g_avi263AacPath, LOCAL); 371 ASSERT_TRUE(initStatus_); 372 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 373 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 374 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 375 ASSERT_NE(sharedMem_, nullptr); 376 ASSERT_TRUE(SetInitValue()); 377 while (!isEOS(eosFlag_)) { 378 for (auto idx : selectedTrackIds_) { 379 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 380 CountFrames(idx); 381 } 382 } 383 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 384 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 385 ASSERT_EQ(frames_[0], 103); 386 ASSERT_EQ(frames_[1], 174); 387 ASSERT_EQ(keyFrames_[0], 103); 388 ASSERT_EQ(keyFrames_[1], 174); 389 RemoveValue(); 390 } 391 392 /** 393 * @tc.name: Demuxer_ReadSample_2240 394 * @tc.desc: copy current sample to buffer, uri 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2240, TestSize.Level1) 398 { 399 InitResource(g_avi263AacUri, URI); 400 ASSERT_TRUE(initStatus_); 401 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 402 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 403 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 404 ASSERT_NE(sharedMem_, nullptr); 405 ASSERT_TRUE(SetInitValue()); 406 while (!isEOS(eosFlag_)) { 407 for (auto idx : selectedTrackIds_) { 408 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 409 CountFrames(idx); 410 } 411 } 412 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 413 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 414 ASSERT_EQ(frames_[0], 103); 415 ASSERT_EQ(frames_[1], 174); 416 ASSERT_EQ(keyFrames_[0], 103); 417 ASSERT_EQ(keyFrames_[1], 174); 418 RemoveValue(); 419 } 420 421 /** 422 * @tc.name: Demuxer_SeekToTime_1065 423 * @tc.desc: seek to the specified time 424 * @tc.type: FUNC 425 */ 426 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_1065, TestSize.Level1) 427 { 428 InitResource(g_tsMpeg4Path, LOCAL); 429 ASSERT_TRUE(initStatus_); 430 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 431 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 432 list<int64_t> toPtsList = {0, 3480, 3640, 3350, 3000, 3100, 4120}; // ms 433 vector<int32_t> videoVals = {103, 103, 103, 15, 15, 15, 11, 11, 11, 19, 20, 19, 27, 27, 27, 24, 26, 24, 1, 1, 1}; 434 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 435 ASSERT_NE(sharedMem_, nullptr); 436 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 437 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 438 ret_ = demuxer_->SeekToTime(*toPts, *mode); 439 if (ret_ != AV_ERR_OK) { 440 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 441 continue; 442 } 443 ReadData(); 444 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 445 ASSERT_EQ(frames_[0], videoVals[numbers_]); 446 numbers_ += 1; 447 RemoveValue(); 448 selectedTrackIds_.clear(); 449 } 450 } 451 } 452 453 /** 454 * @tc.name: Demuxer_SeekToTime_2065 455 * @tc.desc: seek to the specified time 456 * @tc.type: FUNC 457 */ 458 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2065, TestSize.Level1) 459 { 460 InitResource(g_tsMpeg4Uri, URI); 461 ASSERT_TRUE(initStatus_); 462 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 463 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 464 list<int64_t> toPtsList = {0, 3480, 3640, 3350, 3000, 3100, 4120}; // ms 465 vector<int32_t> videoVals = {103, 103, 103, 15, 15, 15, 11, 11, 11, 19, 20, 19, 27, 27, 27, 24, 26, 24, 1, 1, 1}; 466 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 467 ASSERT_NE(sharedMem_, nullptr); 468 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 469 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 470 ret_ = demuxer_->SeekToTime(*toPts, *mode); 471 if (ret_ != AV_ERR_OK) { 472 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 473 continue; 474 } 475 ReadData(); 476 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 477 ASSERT_EQ(frames_[0], videoVals[numbers_]); 478 numbers_ += 1; 479 RemoveValue(); 480 selectedTrackIds_.clear(); 481 } 482 } 483 } 484 485 /** 486 * @tc.name: Demuxer_SeekToTime_2222 487 * @tc.desc: seek to the specified time, local 488 * @tc.type: FUNC 489 */ 490 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2222, TestSize.Level1) 491 { 492 InitResource(g_aviAvcMp3Path, LOCAL); 493 ASSERT_TRUE(initStatus_); 494 ASSERT_TRUE(SetInitValue()); 495 for (auto idx : selectedTrackIds_) { 496 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 497 } 498 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 499 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 500 vector<int32_t> audioVals = {386, 386, 386, 66, 225, 225, 66, 225, 66, 225, 386, 386}; 501 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 502 ASSERT_NE(sharedMem_, nullptr); 503 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 504 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 505 ret_ = demuxer_->SeekToTime(*toPts, *mode); 506 if (ret_ != AV_ERR_OK) { 507 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 508 continue; 509 } 510 ReadData(); 511 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 512 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 513 ASSERT_EQ(frames_[0], videoVals[numbers_]); 514 ASSERT_EQ(frames_[1], audioVals[numbers_]); 515 numbers_ += 1; 516 RemoveValue(); 517 selectedTrackIds_.clear(); 518 } 519 } 520 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 521 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 522 } 523 524 /** 525 * @tc.name: Demuxer_SeekToTime_2232 526 * @tc.desc: seek to the specified time, uri 527 * @tc.type: FUNC 528 */ 529 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2232, TestSize.Level1) 530 { 531 InitResource(g_aviAvcMp3Uri, URI); 532 ASSERT_TRUE(initStatus_); 533 ASSERT_TRUE(SetInitValue()); 534 for (auto idx : selectedTrackIds_) { 535 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 536 } 537 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 538 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 539 vector<int32_t> audioVals = {386, 386, 386, 66, 225, 225, 66, 225, 66, 225, 386, 386}; 540 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 541 ASSERT_NE(sharedMem_, nullptr); 542 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 543 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 544 ret_ = demuxer_->SeekToTime(*toPts, *mode); 545 if (ret_ != AV_ERR_OK) { 546 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 547 continue; 548 } 549 ReadData(); 550 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 551 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 552 ASSERT_EQ(frames_[0], videoVals[numbers_]); 553 ASSERT_EQ(frames_[1], audioVals[numbers_]); 554 numbers_ += 1; 555 RemoveValue(); 556 selectedTrackIds_.clear(); 557 } 558 } 559 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 560 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 561 } 562 563 /** 564 * @tc.name: Demuxer_SeekToTime_2226 565 * @tc.desc: seek to the specified time, local 566 * @tc.type: FUNC 567 */ 568 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2226, TestSize.Level1) 569 { 570 InitResource(g_aviMpeg2Mp2Path, LOCAL); 571 ASSERT_TRUE(initStatus_); 572 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 573 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 574 list<int64_t> toPtsList = {0, 2000, 1920, 2300, 2430, 2600, 3000, 4080}; // ms 575 vector<int32_t> audioVals = {155, 155, 155, 62, 80, 80, 80, 98, 80, 62, 80, 62, 62, 62, 62, 43, 62, 62, 576 25, 43, 43, 6, 6, 6}; 577 vector<int32_t> videoVals = {103, 103, 103, 43, 55, 55, 55, 67, 55, 43, 55, 43, 43, 43, 43, 31, 43, 43, 578 19, 31, 31, 7, 7, 7}; 579 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 580 ASSERT_NE(sharedMem_, nullptr); 581 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 582 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 583 ret_ = demuxer_->SeekToTime(*toPts, *mode); 584 if (ret_ != AV_ERR_OK) { 585 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 586 continue; 587 } 588 ReadData(); 589 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 590 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 591 ASSERT_EQ(frames_[0], videoVals[numbers_]); 592 ASSERT_EQ(frames_[1], audioVals[numbers_]); 593 numbers_ += 1; 594 RemoveValue(); 595 selectedTrackIds_.clear(); 596 } 597 } 598 } 599 600 /** 601 * @tc.name: Demuxer_SeekToTime_2236 602 * @tc.desc: seek to the specified time, uri 603 * @tc.type: FUNC 604 */ 605 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2236, TestSize.Level1) 606 { 607 InitResource(g_aviMpeg2Mp2Uri, URI); 608 ASSERT_TRUE(initStatus_); 609 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 610 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 611 list<int64_t> toPtsList = {0, 2000, 1920, 2300, 2430, 2600, 3000, 4080}; // ms 612 vector<int32_t> audioVals = {155, 155, 155, 62, 80, 80, 80, 98, 80, 62, 80, 62, 62, 62, 62, 43, 62, 62, 613 25, 43, 43, 6, 6, 6}; 614 vector<int32_t> videoVals = {103, 103, 103, 43, 55, 55, 55, 67, 55, 43, 55, 43, 43, 43, 43, 31, 43, 43, 615 19, 31, 31, 7, 7, 7}; 616 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 617 ASSERT_NE(sharedMem_, nullptr); 618 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 619 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 620 ret_ = demuxer_->SeekToTime(*toPts, *mode); 621 if (ret_ != AV_ERR_OK) { 622 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 623 continue; 624 } 625 ReadData(); 626 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 627 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 628 ASSERT_EQ(frames_[0], videoVals[numbers_]); 629 ASSERT_EQ(frames_[1], audioVals[numbers_]); 630 numbers_ += 1; 631 RemoveValue(); 632 selectedTrackIds_.clear(); 633 } 634 } 635 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 636 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 637 } 638 639 /** 640 * @tc.name: Demuxer_SeekToTime_2227 641 * @tc.desc: seek to the specified time, local 642 * @tc.type: FUNC 643 */ 644 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2227, TestSize.Level1) 645 { 646 InitResource(g_aviMpeg4Mp3Path, LOCAL); 647 ASSERT_TRUE(initStatus_); 648 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 649 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 650 list<int64_t> toPtsList = {0, 2000, 1620, 2300, 2430, 2600, 3000, 4080}; // ms 651 vector<int32_t> audioVals = {156, 156, 156, 78, 96, 78, 78, 96, 96, 60, 78, 60, 60, 78, 60, 41, 60, 60, 652 41, 41, 41, 4, 4, 4}; 653 vector<int32_t> videoVals = {103, 103, 103, 55, 67, 55, 55, 67, 67, 43, 55, 43, 43, 55, 43, 31, 43, 43, 654 31, 31, 31, 7, 7, 7}; 655 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 656 ASSERT_NE(sharedMem_, nullptr); 657 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 658 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 659 ret_ = demuxer_->SeekToTime(*toPts, *mode); 660 if (ret_ != AV_ERR_OK) { 661 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 662 continue; 663 } 664 ReadData(); 665 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 666 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 667 ASSERT_EQ(frames_[0], videoVals[numbers_]); 668 ASSERT_EQ(frames_[1], audioVals[numbers_]); 669 numbers_ += 1; 670 RemoveValue(); 671 selectedTrackIds_.clear(); 672 } 673 } 674 } 675 676 /** 677 * @tc.name: Demuxer_SeekToTime_2237 678 * @tc.desc: seek to the specified time, uri 679 * @tc.type: FUNC 680 */ 681 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2237, TestSize.Level1) 682 { 683 InitResource(g_aviMpeg4Mp3Uri, URI); 684 ASSERT_TRUE(initStatus_); 685 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 686 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 687 list<int64_t> toPtsList = {0, 2000, 1620, 2300, 2430, 2600, 3000, 4080}; // ms 688 vector<int32_t> audioVals = {156, 156, 156, 78, 96, 78, 78, 96, 96, 60, 78, 60, 60, 78, 60, 41, 60, 60, 689 41, 41, 41, 4, 4, 4}; 690 vector<int32_t> videoVals = {103, 103, 103, 55, 67, 55, 55, 67, 67, 43, 55, 43, 43, 55, 43, 31, 43, 43, 691 31, 31, 31, 7, 7, 7}; 692 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 693 ASSERT_NE(sharedMem_, nullptr); 694 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 695 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 696 ret_ = demuxer_->SeekToTime(*toPts, *mode); 697 if (ret_ != AV_ERR_OK) { 698 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 699 continue; 700 } 701 ReadData(); 702 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 703 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 704 ASSERT_EQ(frames_[0], videoVals[numbers_]); 705 ASSERT_EQ(frames_[1], audioVals[numbers_]); 706 numbers_ += 1; 707 RemoveValue(); 708 selectedTrackIds_.clear(); 709 } 710 } 711 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 712 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 713 } 714 715 /** 716 * @tc.name: Demuxer_SeekToTime_2229 717 * @tc.desc: seek to the specified time, local 718 * @tc.type: FUNC 719 */ 720 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2229, TestSize.Level1) 721 { 722 InitResource(g_aviMpeg4PcmPath, LOCAL); 723 ASSERT_TRUE(initStatus_); 724 ASSERT_TRUE(SetInitValue()); 725 for (auto idx : selectedTrackIds_) { 726 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 727 } 728 list<int64_t> toPtsList = {0, 4450, 7000, 2000}; // ms 729 vector<int32_t> videoVals = {604, 604, 604, 328, 340, 340, 184, 184, 184, 484, 484, 484}; 730 vector<int32_t> audioVals = {433, 433, 433, 235, 244, 244, 132, 132, 132, 347, 347, 347}; 731 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 732 ASSERT_NE(sharedMem_, nullptr); 733 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 734 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 735 ret_ = demuxer_->SeekToTime(*toPts, *mode); 736 if (ret_ != AV_ERR_OK) { 737 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 738 continue; 739 } 740 ReadData(); 741 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 742 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 743 ASSERT_EQ(frames_[0], videoVals[numbers_]); 744 ASSERT_EQ(frames_[1], audioVals[numbers_]); 745 numbers_ += 1; 746 RemoveValue(); 747 selectedTrackIds_.clear(); 748 } 749 } 750 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 751 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 752 } 753 754 /** 755 * @tc.name: Demuxer_SeekToTime_2239 756 * @tc.desc: seek to the specified time, uri 757 * @tc.type: FUNC 758 */ 759 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2239, TestSize.Level1) 760 { 761 InitResource(g_aviMpeg4PcmUri, URI); 762 ASSERT_TRUE(initStatus_); 763 ASSERT_TRUE(SetInitValue()); 764 for (auto idx : selectedTrackIds_) { 765 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 766 } 767 list<int64_t> toPtsList = {0, 4450, 7000, 2000}; // ms 768 vector<int32_t> videoVals = {604, 604, 604, 328, 340, 340, 184, 184, 184, 484, 484, 484}; 769 vector<int32_t> audioVals = {433, 433, 433, 235, 244, 244, 132, 132, 132, 347, 347, 347}; 770 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 771 ASSERT_NE(sharedMem_, nullptr); 772 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 773 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 774 ret_ = demuxer_->SeekToTime(*toPts, *mode); 775 if (ret_ != AV_ERR_OK) { 776 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 777 continue; 778 } 779 ReadData(); 780 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 781 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 782 ASSERT_EQ(frames_[0], videoVals[numbers_]); 783 ASSERT_EQ(frames_[1], audioVals[numbers_]); 784 numbers_ += 1; 785 RemoveValue(); 786 selectedTrackIds_.clear(); 787 } 788 } 789 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 790 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 791 } 792 793 /** 794 * @tc.name: Demuxer_SeekToTime_2230 795 * @tc.desc: seek to the specified time, local 796 * @tc.type: FUNC 797 */ 798 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2230, TestSize.Level1) 799 { 800 InitResource(g_avi263AacPath, LOCAL); 801 ASSERT_TRUE(initStatus_); 802 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 803 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 804 list<int64_t> toPtsList = {0, 2000, 1920, 2300, 2430, 2600, 3000, 4080}; // ms 805 vector<int32_t> audioVals = {174, 174, 174, 69, 90, 90, 90, 110, 90, 69, 90, 69, 69, 69, 69, 48, 69, 69, 806 28, 48, 48, 7, 7, 7}; 807 vector<int32_t> videoVals = {103, 103, 103, 43, 55, 55, 55, 67, 55, 43, 55, 43, 43, 43, 43, 31, 43, 43, 808 19, 31, 31, 7, 7, 7}; 809 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 810 ASSERT_NE(sharedMem_, nullptr); 811 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 812 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 813 ret_ = demuxer_->SeekToTime(*toPts, *mode); 814 if (ret_ != AV_ERR_OK) { 815 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 816 continue; 817 } 818 ReadData(); 819 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 820 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 821 ASSERT_EQ(frames_[0], videoVals[numbers_]); 822 ASSERT_EQ(frames_[1], audioVals[numbers_]); 823 numbers_ += 1; 824 RemoveValue(); 825 selectedTrackIds_.clear(); 826 } 827 } 828 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 829 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 830 } 831 832 /** 833 * @tc.name: Demuxer_SeekToTime_2240 834 * @tc.desc: seek to the specified time, uri 835 * @tc.type: FUNC 836 */ 837 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2240, TestSize.Level1) 838 { 839 InitResource(g_avi263AacUri, URI); 840 ASSERT_TRUE(initStatus_); 841 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 842 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 843 list<int64_t> toPtsList = {0, 2000, 1920, 2300, 2430, 2600, 3000, 4080}; // ms 844 vector<int32_t> audioVals = {174, 174, 174, 69, 90, 90, 90, 110, 90, 69, 90, 69, 69, 69, 69, 48, 69, 69, 845 28, 48, 48, 7, 7, 7}; 846 vector<int32_t> videoVals = {103, 103, 103, 43, 55, 55, 55, 67, 55, 43, 55, 43, 43, 43, 43, 31, 43, 43, 847 19, 31, 31, 7, 7, 7}; 848 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 849 ASSERT_NE(sharedMem_, nullptr); 850 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 851 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 852 ret_ = demuxer_->SeekToTime(*toPts, *mode); 853 if (ret_ != AV_ERR_OK) { 854 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 855 continue; 856 } 857 ReadData(); 858 printf("time = %" PRId64 " | frames_[0]=%d | kFrames[0]=%d\n", *toPts, frames_[0], keyFrames_[0]); 859 printf("time = %" PRId64 " | frames_[1]=%d | kFrames[1]=%d\n", *toPts, frames_[1], keyFrames_[1]); 860 ASSERT_EQ(frames_[0], videoVals[numbers_]); 861 ASSERT_EQ(frames_[1], audioVals[numbers_]); 862 numbers_ += 1; 863 RemoveValue(); 864 selectedTrackIds_.clear(); 865 } 866 } 867 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 868 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 869 } 870 /** 871 * @tc.name: Demuxer_ReadSample_2280 872 * @tc.desc: copy current sample to buffer (h264-aac) local 873 * @tc.type: FUNC 874 */ 875 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2280, TestSize.Level1) 876 { 877 InitResource(g_h264aacPath, LOCAL); 878 ASSERT_TRUE(initStatus_); 879 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 880 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 881 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 882 ASSERT_NE(sharedMem_, nullptr); 883 ASSERT_TRUE(SetInitValue()); 884 while (!isEOS(eosFlag_)) { 885 for (auto idx : selectedTrackIds_) { 886 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 887 CountFrames(idx); 888 } 889 } 890 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 891 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 892 ASSERT_EQ(frames_[0], 602); 893 ASSERT_EQ(frames_[1], 434); 894 ASSERT_EQ(keyFrames_[0], 3); 895 ASSERT_EQ(keyFrames_[1], 434); 896 RemoveValue(); 897 } 898 899 /** 900 * @tc.name: Demuxer_ReadSample_2281 901 * @tc.desc: copy current sample to buffer (h264-aac) uri 902 * @tc.type: FUNC 903 */ 904 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2281, TestSize.Level1) 905 { 906 InitResource(g_h264aacUri, URI); 907 ASSERT_TRUE(initStatus_); 908 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 909 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 910 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 911 ASSERT_NE(sharedMem_, nullptr); 912 ASSERT_TRUE(SetInitValue()); 913 while (!isEOS(eosFlag_)) { 914 for (auto idx : selectedTrackIds_) { 915 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 916 CountFrames(idx); 917 } 918 } 919 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 920 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 921 ASSERT_EQ(frames_[0], 602); 922 ASSERT_EQ(frames_[1], 434); 923 ASSERT_EQ(keyFrames_[0], 3); 924 ASSERT_EQ(keyFrames_[1], 434); 925 RemoveValue(); 926 } 927 928 /** 929 * @tc.name: Demuxer_ReadSample_2282 930 * @tc.desc: copy current sample to buffer (h264-mp3) local 931 * @tc.type: FUNC 932 */ 933 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2282, TestSize.Level1) 934 { 935 InitResource(g_h264mp3Path, LOCAL); 936 ASSERT_TRUE(initStatus_); 937 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 938 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 939 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 940 ASSERT_NE(sharedMem_, nullptr); 941 ASSERT_TRUE(SetInitValue()); 942 while (!isEOS(eosFlag_)) { 943 for (auto idx : selectedTrackIds_) { 944 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 945 CountFrames(idx); 946 } 947 } 948 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 949 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 950 ASSERT_EQ(frames_[0], 602); 951 ASSERT_EQ(frames_[1], 386); 952 ASSERT_EQ(keyFrames_[0], 3); 953 ASSERT_EQ(keyFrames_[1], 386); 954 RemoveValue(); 955 } 956 957 /** 958 * @tc.name: Demuxer_ReadSample_2283 959 * @tc.desc: copy current sample to buffer (h264-mp3) uri 960 * @tc.type: FUNC 961 */ 962 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2283, TestSize.Level1) 963 { 964 InitResource(g_h264mp3Uri, URI); 965 ASSERT_TRUE(initStatus_); 966 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 967 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 968 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 969 ASSERT_NE(sharedMem_, nullptr); 970 ASSERT_TRUE(SetInitValue()); 971 while (!isEOS(eosFlag_)) { 972 for (auto idx : selectedTrackIds_) { 973 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 974 CountFrames(idx); 975 } 976 } 977 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 978 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 979 ASSERT_EQ(frames_[0], 602); 980 ASSERT_EQ(frames_[1], 386); 981 ASSERT_EQ(keyFrames_[0], 3); 982 ASSERT_EQ(keyFrames_[1], 386); 983 RemoveValue(); 984 } 985 986 /** 987 * @tc.name: Demuxer_ReadSample_2284 988 * @tc.desc: copy current sample to buffer (h264-vorbis) local 989 * @tc.type: FUNC 990 */ 991 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2284, TestSize.Level1) 992 { 993 InitResource(g_h264vorPath, LOCAL); 994 ASSERT_TRUE(initStatus_); 995 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 996 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 997 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 998 ASSERT_NE(sharedMem_, nullptr); 999 ASSERT_TRUE(SetInitValue()); 1000 while (!isEOS(eosFlag_)) { 1001 for (auto idx : selectedTrackIds_) { 1002 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1003 CountFrames(idx); 1004 } 1005 } 1006 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1007 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1008 ASSERT_EQ(frames_[0], 602); 1009 ASSERT_EQ(frames_[1], 609); 1010 ASSERT_EQ(keyFrames_[0], 3); 1011 ASSERT_EQ(keyFrames_[1], 609); 1012 RemoveValue(); 1013 } 1014 1015 /** 1016 * @tc.name: Demuxer_ReadSample_2285 1017 * @tc.desc: copy current sample to buffer (h264-vorbis) uri 1018 * @tc.type: FUNC 1019 */ 1020 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2285, TestSize.Level1) 1021 { 1022 InitResource(g_h264vorUri, URI); 1023 ASSERT_TRUE(initStatus_); 1024 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1025 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1026 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1027 ASSERT_NE(sharedMem_, nullptr); 1028 ASSERT_TRUE(SetInitValue()); 1029 while (!isEOS(eosFlag_)) { 1030 for (auto idx : selectedTrackIds_) { 1031 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1032 CountFrames(idx); 1033 } 1034 } 1035 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1036 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1037 ASSERT_EQ(frames_[0], 602); 1038 ASSERT_EQ(frames_[1], 609); 1039 ASSERT_EQ(keyFrames_[0], 3); 1040 ASSERT_EQ(keyFrames_[1], 609); 1041 RemoveValue(); 1042 } 1043 1044 /** 1045 * @tc.name: Demuxer_ReadSample_2286 1046 * @tc.desc: copy current sample to buffer (MPEG4-mp2) local 1047 * @tc.type: FUNC 1048 */ 1049 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2286, TestSize.Level1) 1050 { 1051 InitResource(g_mpg4mp2Path, LOCAL); 1052 ASSERT_TRUE(initStatus_); 1053 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1054 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1055 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1056 ASSERT_NE(sharedMem_, nullptr); 1057 ASSERT_TRUE(SetInitValue()); 1058 while (!isEOS(eosFlag_)) { 1059 for (auto idx : selectedTrackIds_) { 1060 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1061 CountFrames(idx); 1062 } 1063 } 1064 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1065 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1066 ASSERT_EQ(frames_[0], 602); 1067 ASSERT_EQ(frames_[1], 385); 1068 ASSERT_EQ(keyFrames_[0], 51); 1069 ASSERT_EQ(keyFrames_[1], 385); 1070 RemoveValue(); 1071 } 1072 1073 /** 1074 * @tc.name: Demuxer_ReadSample_2287 1075 * @tc.desc: copy current sample to buffer (MPEG4-mp2) uri 1076 * @tc.type: FUNC 1077 */ 1078 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2287, TestSize.Level1) 1079 { 1080 InitResource(g_mpg4mp2Uri, URI); 1081 ASSERT_TRUE(initStatus_); 1082 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1083 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1084 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1085 ASSERT_NE(sharedMem_, nullptr); 1086 ASSERT_TRUE(SetInitValue()); 1087 while (!isEOS(eosFlag_)) { 1088 for (auto idx : selectedTrackIds_) { 1089 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1090 CountFrames(idx); 1091 } 1092 } 1093 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1094 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1095 ASSERT_EQ(frames_[0], 602); 1096 ASSERT_EQ(frames_[1], 385); 1097 ASSERT_EQ(keyFrames_[0], 51); 1098 ASSERT_EQ(keyFrames_[1], 385); 1099 RemoveValue(); 1100 } 1101 1102 /** 1103 * @tc.name: Demuxer_ReadSample_2314 1104 * @tc.desc: copy current sample to buffer, local (MPEG4 aac) 1105 * @tc.type: FUNC 1106 */ 1107 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2314, TestSize.Level1) 1108 { 1109 InitResource(g_mpg4mp4Path, LOCAL); 1110 ASSERT_TRUE(initStatus_); 1111 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1112 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1113 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1114 ASSERT_NE(sharedMem_, nullptr); 1115 ASSERT_TRUE(SetInitValue()); 1116 while (!isEOS(eosFlag_)) { 1117 for (auto idx : selectedTrackIds_) { 1118 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1119 CountFrames(idx); 1120 } 1121 } 1122 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1123 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1124 ASSERT_EQ(frames_[0], 602); 1125 ASSERT_EQ(frames_[1], 434); 1126 ASSERT_EQ(keyFrames_[0], 51); 1127 ASSERT_EQ(keyFrames_[1], 434); 1128 RemoveValue(); 1129 } 1130 1131 /** 1132 * @tc.name: Demuxer_ReadSample_2315 1133 * @tc.desc: copy current sample to buffer, uri (MPEG4 aac) 1134 * @tc.type: FUNC 1135 */ 1136 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_2315, TestSize.Level1) 1137 { 1138 InitResource(g_mpg4mp4Uri, URI); 1139 ASSERT_TRUE(initStatus_); 1140 ASSERT_EQ(demuxer_->SelectTrackByID(0), AV_ERR_OK); 1141 ASSERT_EQ(demuxer_->SelectTrackByID(1), AV_ERR_OK); 1142 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1143 ASSERT_NE(sharedMem_, nullptr); 1144 ASSERT_TRUE(SetInitValue()); 1145 while (!isEOS(eosFlag_)) { 1146 for (auto idx : selectedTrackIds_) { 1147 ASSERT_EQ(demuxer_->ReadSample(idx, sharedMem_, &info_, flag_), AV_ERR_OK); 1148 CountFrames(idx); 1149 } 1150 } 1151 printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]); 1152 printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]); 1153 ASSERT_EQ(frames_[0], 602); 1154 ASSERT_EQ(frames_[1], 434); 1155 ASSERT_EQ(keyFrames_[0], 51); 1156 ASSERT_EQ(keyFrames_[1], 434); 1157 RemoveValue(); 1158 } 1159 1160 /** 1161 * @tc.name: Demuxer_SeekToTime_2288 1162 * @tc.desc: seek to the specified time (h264-aac) local 1163 * @tc.type: FUNC 1164 */ 1165 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2281, TestSize.Level1) 1166 { 1167 InitResource(g_h264aacPath, LOCAL); 1168 ASSERT_TRUE(initStatus_); 1169 ASSERT_TRUE(SetInitValue()); 1170 for (auto idx : selectedTrackIds_) { 1171 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1172 } 1173 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1174 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1175 vector<int32_t> audioVals = {434, 434, 434, 74, 255, 255, 74, 255, 74, 254, 434, 434}; 1176 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1177 ASSERT_NE(sharedMem_, nullptr); 1178 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1179 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1180 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1181 if (ret_ != AV_ERR_OK) { 1182 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1183 continue; 1184 } 1185 ReadData(); 1186 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1187 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1188 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1189 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1190 numbers_ += 1; 1191 RemoveValue(); 1192 selectedTrackIds_.clear(); 1193 } 1194 } 1195 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1196 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1197 } 1198 1199 /** 1200 * @tc.name: Demuxer_SeekToTime_2289 1201 * @tc.desc: seek to the specified time (h264-aac) uri 1202 * @tc.type: FUNC 1203 */ 1204 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2289, TestSize.Level1) 1205 { 1206 InitResource(g_h264aacUri, URI); 1207 ASSERT_TRUE(initStatus_); 1208 ASSERT_TRUE(SetInitValue()); 1209 for (auto idx : selectedTrackIds_) { 1210 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1211 } 1212 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1213 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1214 vector<int32_t> audioVals = {434, 434, 434, 74, 255, 255, 74, 255, 74, 254, 434, 434}; 1215 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1216 ASSERT_NE(sharedMem_, nullptr); 1217 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1218 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1219 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1220 if (ret_ != AV_ERR_OK) { 1221 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1222 continue; 1223 } 1224 ReadData(); 1225 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1226 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1227 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1228 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1229 numbers_ += 1; 1230 RemoveValue(); 1231 selectedTrackIds_.clear(); 1232 } 1233 } 1234 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1235 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1236 } 1237 1238 /** 1239 * @tc.name: Demuxer_SeekToTime_2290 1240 * @tc.desc: seek to the specified time (h264-mp3) local 1241 * @tc.type: FUNC 1242 */ 1243 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2290, TestSize.Level1) 1244 { 1245 InitResource(g_h264mp3Path, LOCAL); 1246 ASSERT_TRUE(initStatus_); 1247 ASSERT_TRUE(SetInitValue()); 1248 for (auto idx : selectedTrackIds_) { 1249 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1250 } 1251 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1252 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1253 vector<int32_t> audioVals = {386, 386, 386, 66, 226, 226, 66, 226, 66, 225, 386, 386}; 1254 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1255 ASSERT_NE(sharedMem_, nullptr); 1256 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1257 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1258 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1259 if (ret_ != AV_ERR_OK) { 1260 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1261 continue; 1262 } 1263 ReadData(); 1264 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1265 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1266 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1267 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1268 numbers_ += 1; 1269 RemoveValue(); 1270 selectedTrackIds_.clear(); 1271 } 1272 } 1273 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1274 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1275 } 1276 1277 /** 1278 * @tc.name: Demuxer_SeekToTime_2291 1279 * @tc.desc: seek to the specified time (h264-mp3) uri 1280 * @tc.type: FUNC 1281 */ 1282 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2291, TestSize.Level1) 1283 { 1284 InitResource(g_h264mp3Uri, URI); 1285 ASSERT_TRUE(initStatus_); 1286 ASSERT_TRUE(SetInitValue()); 1287 for (auto idx : selectedTrackIds_) { 1288 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1289 } 1290 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1291 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1292 vector<int32_t> audioVals = {386, 386, 386, 66, 226, 226, 66, 226, 66, 225, 386, 386}; 1293 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1294 ASSERT_NE(sharedMem_, nullptr); 1295 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1296 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1297 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1298 if (ret_ != AV_ERR_OK) { 1299 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1300 continue; 1301 } 1302 ReadData(); 1303 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1304 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1305 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1306 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1307 numbers_ += 1; 1308 RemoveValue(); 1309 selectedTrackIds_.clear(); 1310 } 1311 } 1312 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1313 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1314 } 1315 1316 /** 1317 * @tc.name: Demuxer_SeekToTime_2292 1318 * @tc.desc: seek to the specified time (h264-vorbis) local 1319 * @tc.type: FUNC 1320 */ 1321 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2292, TestSize.Level1) 1322 { 1323 InitResource(g_h264vorPath, LOCAL); 1324 ASSERT_TRUE(initStatus_); 1325 ASSERT_TRUE(SetInitValue()); 1326 for (auto idx : selectedTrackIds_) { 1327 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1328 } 1329 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1330 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1331 vector<int32_t> audioVals = {609, 609, 609, 106, 364, 364, 106, 364, 106, 363, 609, 609}; 1332 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1333 ASSERT_NE(sharedMem_, nullptr); 1334 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1335 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1336 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1337 if (ret_ != AV_ERR_OK) { 1338 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1339 continue; 1340 } 1341 ReadData(); 1342 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1343 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1344 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1345 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1346 numbers_ += 1; 1347 RemoveValue(); 1348 selectedTrackIds_.clear(); 1349 } 1350 } 1351 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1352 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1353 } 1354 1355 /** 1356 * @tc.name: Demuxer_SeekToTime_2293 1357 * @tc.desc: seek to the specified time (h264-vorbis) uri 1358 * @tc.type: FUNC 1359 */ 1360 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2293, TestSize.Level1) 1361 { 1362 InitResource(g_h264vorUri, URI); 1363 ASSERT_TRUE(initStatus_); 1364 ASSERT_TRUE(SetInitValue()); 1365 for (auto idx : selectedTrackIds_) { 1366 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1367 } 1368 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1369 vector<int32_t> videoVals = {602, 602, 602, 102, 352, 352, 102, 352, 102, 352, 602, 602}; 1370 vector<int32_t> audioVals = {609, 609, 609, 106, 364, 364, 106, 364, 106, 363, 609, 609}; 1371 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1372 ASSERT_NE(sharedMem_, nullptr); 1373 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1374 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1375 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1376 if (ret_ != AV_ERR_OK) { 1377 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1378 continue; 1379 } 1380 ReadData(); 1381 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1382 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1383 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1384 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1385 numbers_ += 1; 1386 RemoveValue(); 1387 selectedTrackIds_.clear(); 1388 } 1389 } 1390 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1391 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1392 } 1393 1394 /** 1395 * @tc.name: Demuxer_SeekToTime_2294 1396 * @tc.desc: seek to the specified time (mpeg4-mp2) local 1397 * @tc.type: FUNC 1398 */ 1399 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2294, TestSize.Level1) 1400 { 1401 InitResource(g_mpg4mp2Path, LOCAL); 1402 ASSERT_TRUE(initStatus_); 1403 ASSERT_TRUE(SetInitValue()); 1404 for (auto idx : selectedTrackIds_) { 1405 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1406 } 1407 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1408 vector<int32_t> videoVals = {602, 602, 602, 326, 338, 338, 182, 182, 182, 482, 482, 482}; 1409 vector<int32_t> audioVals = {385, 385, 385, 208, 217, 217, 116, 117, 116, 308, 309, 308}; 1410 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1411 ASSERT_NE(sharedMem_, nullptr); 1412 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1413 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1414 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1415 if (ret_ != AV_ERR_OK) { 1416 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1417 continue; 1418 } 1419 ReadData(); 1420 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1421 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1422 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1423 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1424 numbers_ += 1; 1425 RemoveValue(); 1426 selectedTrackIds_.clear(); 1427 } 1428 } 1429 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1430 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1431 } 1432 1433 /** 1434 * @tc.name: Demuxer_SeekToTime_2295 1435 * @tc.desc: seek to the specified time (mpeg4-mp2) uri 1436 * @tc.type: FUNC 1437 */ 1438 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2295, TestSize.Level1) 1439 { 1440 InitResource(g_mpg4mp2Uri, URI); 1441 ASSERT_TRUE(initStatus_); 1442 ASSERT_TRUE(SetInitValue()); 1443 for (auto idx : selectedTrackIds_) { 1444 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1445 } 1446 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1447 vector<int32_t> videoVals = {602, 602, 602, 326, 338, 338, 182, 182, 182, 482, 482, 482}; 1448 vector<int32_t> audioVals = {385, 385, 385, 208, 217, 217, 116, 117, 116, 308, 309, 308}; 1449 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1450 ASSERT_NE(sharedMem_, nullptr); 1451 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1452 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1453 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1454 if (ret_ != AV_ERR_OK) { 1455 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1456 continue; 1457 } 1458 ReadData(); 1459 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1460 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1461 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1462 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1463 numbers_ += 1; 1464 RemoveValue(); 1465 selectedTrackIds_.clear(); 1466 } 1467 } 1468 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1469 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1470 } 1471 1472 /** 1473 * @tc.name: Demuxer_SeekToTime_2316 1474 * @tc.desc: seek to the specified time, local (MPEG4 aac) 1475 * @tc.type: FUNC 1476 */ 1477 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2316, TestSize.Level1) 1478 { 1479 InitResource(g_mpg4mp4Path, LOCAL); 1480 ASSERT_TRUE(initStatus_); 1481 ASSERT_TRUE(SetInitValue()); 1482 for (auto idx : selectedTrackIds_) { 1483 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1484 } 1485 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1486 vector<int32_t> videoVals = {602, 602, 602, 326, 338, 338, 182, 182, 182, 482, 482, 482}; 1487 vector<int32_t> audioVals = {433, 433, 433, 233, 243, 243, 130, 131, 130, 345, 346, 345}; 1488 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1489 ASSERT_NE(sharedMem_, nullptr); 1490 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1491 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1492 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1493 if (ret_ != AV_ERR_OK) { 1494 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1495 continue; 1496 } 1497 ReadData(); 1498 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1499 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1500 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1501 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1502 numbers_ += 1; 1503 RemoveValue(); 1504 selectedTrackIds_.clear(); 1505 } 1506 } 1507 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1508 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1509 } 1510 1511 /** 1512 * @tc.name: Demuxer_SeekToTime_2317 1513 * @tc.desc: seek to the specified time uri (MPEG4 aac) 1514 * @tc.type: FUNC 1515 */ 1516 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_2317, TestSize.Level1) 1517 { 1518 InitResource(g_mpg4mp4Uri, URI); 1519 ASSERT_TRUE(initStatus_); 1520 ASSERT_TRUE(SetInitValue()); 1521 for (auto idx : selectedTrackIds_) { 1522 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1523 } 1524 list<int64_t> toPtsList = {0, 4500, 7000, 2000}; // ms 1525 vector<int32_t> videoVals = {602, 602, 602, 326, 338, 338, 182, 182, 182, 482, 482, 482}; 1526 vector<int32_t> audioVals = {433, 433, 433, 233, 243, 243, 130, 131, 130, 345, 346, 345}; 1527 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1528 ASSERT_NE(sharedMem_, nullptr); 1529 for (auto toPts = toPtsList.begin(); toPts != toPtsList.end(); toPts++) { 1530 for (auto mode = seekModes.begin(); mode != seekModes.end(); mode++) { 1531 ret_ = demuxer_->SeekToTime(*toPts, *mode); 1532 if (ret_ != AV_ERR_OK) { 1533 printf("seek failed, time = %" PRId64 " | ret = %d\n", *toPts, ret_); 1534 continue; 1535 } 1536 ReadData(); 1537 printf("time = %" PRId64 " | frames_[0]=%d\n", *toPts, frames_[0]); 1538 printf("time = %" PRId64 " | frames_[1]=%d\n", *toPts, frames_[1]); 1539 ASSERT_EQ(frames_[0], videoVals[numbers_]); 1540 ASSERT_EQ(frames_[1], audioVals[numbers_]); 1541 numbers_ += 1; 1542 RemoveValue(); 1543 selectedTrackIds_.clear(); 1544 } 1545 } 1546 ASSERT_NE(demuxer_->SeekToTime(11000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1547 ASSERT_NE(demuxer_->SeekToTime(-1000, SeekMode::SEEK_NEXT_SYNC), AV_ERR_OK); 1548 } 1549 1550 std::map<std::string, std::map<std::string, std::vector<int32_t>>> infoMap = { 1551 {"muxer264Aac", {{"frames", {430, 601, 430, 601, 601}}, {"kFrames", {430, 3, 430, 3, 3}}}}, 1552 }; 1553 1554 /** 1555 * @tc.name: Demuxer_ReadSample_Auxl_0003 1556 * @tc.desc: copy current sample to buffer, local(mp4 264 aac auxl local) 1557 * @tc.type: FUNC 1558 */ 1559 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_Auxl_0003, TestSize.Level1) 1560 { 1561 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) { 1562 ReadSample(g_mp4AvcAacAuxlPath, LOCAL); 1563 for (auto idx : selectedTrackIds_) { 1564 ASSERT_EQ(frames_[idx], infoMap["muxer264Aac"]["frames"][idx]); 1565 ASSERT_EQ(keyFrames_[idx], infoMap["muxer264Aac"]["kFrames"][idx]); 1566 } 1567 RemoveValue(); 1568 selectedTrackIds_.clear(); 1569 } 1570 } 1571 1572 /** 1573 * @tc.name: Demuxer_ReadSample_Auxl_0004 1574 * @tc.desc: copy current sample to buffer, uri(mp4 264 aac auxl uri) 1575 * @tc.type: FUNC 1576 */ 1577 HWTEST_F(DemuxerUnitTest, Demuxer_ReadSample_Auxl_0004, TestSize.Level1) 1578 { 1579 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) { 1580 ReadSample(g_mp4AvcAacAuxlUri, URI); 1581 for (auto idx : selectedTrackIds_) { 1582 ASSERT_EQ(frames_[idx], infoMap["muxer264Aac"]["frames"][idx]); 1583 ASSERT_EQ(keyFrames_[idx], infoMap["muxer264Aac"]["kFrames"][idx]); 1584 } 1585 RemoveValue(); 1586 selectedTrackIds_.clear(); 1587 } 1588 } 1589 1590 /** 1591 * @tc.name: Demuxer_SeekToTime_Auxl_0003 1592 * @tc.desc: seek to the specified time(mp4 264 aac auxl local) 1593 * @tc.type: FUNC 1594 */ 1595 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_Auxl_0003, TestSize.Level1) 1596 { 1597 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) { 1598 InitResource(g_mp4AvcAacAuxlPath, LOCAL); 1599 ASSERT_TRUE(initStatus_); 1600 SetInitValue(); 1601 for (auto idx : selectedTrackIds_) { 1602 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1603 } 1604 list<int64_t> toPtsList = {0, 5000, 9000, 10000}; // ms 1605 vector<int32_t> videoVals = {601, 601, 601, 101, 351, 351, 101, 101, 101, 101}; 1606 vector<int32_t> audioVals = {430, 430, 430, 71, 251, 251, 72, 72, 72, 72}; 1607 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1608 ASSERT_NE(sharedMem_, nullptr); 1609 SeekTest(toPtsList, seekModes, {audioVals, videoVals, audioVals, videoVals, videoVals}); 1610 ASSERT_TRUE(seekTestFlag_); 1611 } 1612 } 1613 1614 /** 1615 * @tc.name: Demuxer_SeekToTime_Auxl_0004 1616 * @tc.desc: seek to the specified time(mp4 264 aac auxl uri) 1617 * @tc.type: FUNC 1618 */ 1619 HWTEST_F(DemuxerUnitTest, Demuxer_SeekToTime_Auxl_0004, TestSize.Level1) 1620 { 1621 if (access(HEVC_LIB_PATH.c_str(), F_OK) == 0) { 1622 InitResource(g_mp4AvcAacAuxlUri, URI); 1623 ASSERT_TRUE(initStatus_); 1624 SetInitValue(); 1625 for (auto idx : selectedTrackIds_) { 1626 ASSERT_EQ(demuxer_->SelectTrackByID(idx), AV_ERR_OK); 1627 } 1628 list<int64_t> toPtsList = {0, 5000, 9000, 10000}; // ms 1629 vector<int32_t> videoVals = {601, 601, 601, 101, 351, 351, 101, 101, 101, 101}; 1630 vector<int32_t> audioVals = {430, 430, 430, 71, 251, 251, 72, 72, 72, 72}; 1631 sharedMem_ = AVMemoryMockFactory::CreateAVMemoryMock(bufferSize_); 1632 ASSERT_NE(sharedMem_, nullptr); 1633 SeekTest(toPtsList, seekModes, {audioVals, videoVals, audioVals, videoVals, videoVals}); 1634 ASSERT_TRUE(seekTestFlag_); 1635 } 1636 } 1637 } // namespace 1638