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