1/* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "gtest/gtest.h" 17 18#include "native_avcodec_base.h" 19#include "native_avdemuxer.h" 20#include "native_avformat.h" 21#include "native_avsource.h" 22 23#include <iostream> 24#include <cstdio> 25#include <string> 26#include <fcntl.h> 27#include <thread> 28#include <securec.h> 29 30namespace OHOS { 31namespace Media { 32class DemuxerReliNdkTest : public testing::Test { 33public: 34 // SetUpTestCase: Called before all test cases 35 static void SetUpTestCase(void); 36 // TearDownTestCase: Called after all test case 37 static void TearDownTestCase(void); 38 // SetUp: Called before each test cases 39 void SetUp(void); 40 // TearDown: Called after each test cases 41 void TearDown(void); 42}; 43 44static OH_AVMemory *memory = nullptr; 45static OH_AVSource *source = nullptr; 46static OH_AVDemuxer *demuxer = nullptr; 47static OH_AVFormat *sourceFormat = nullptr; 48static OH_AVFormat *trackFormat = nullptr; 49const char *URI2 = "http://192.168.3.11:8080/share/audio/AAC_48000_1.aac"; 50const char *URI1 = "http://192.168.3.11:8080/share/audio/MP3_48000_1.mp3"; 51static int32_t g_trackCount; 52static int32_t g_width = 3840; 53static int32_t g_height = 2160; 54static int32_t g_maxThread = 16; 55OH_AVSource *source_list[16] = {}; 56OH_AVMemory *memory_list[16] = {}; 57OH_AVDemuxer *demuxer_list[16] = {}; 58int g_fdList[16] = {}; 59int32_t g_track = 2; 60 61void DemuxerReliNdkTest::SetUpTestCase() {} 62void DemuxerReliNdkTest::TearDownTestCase() {} 63void DemuxerReliNdkTest::SetUp() 64{ 65 memory = OH_AVMemory_Create(g_width * g_height); 66 g_trackCount = 0; 67} 68void DemuxerReliNdkTest::TearDown() 69{ 70 if (trackFormat != nullptr) { 71 OH_AVFormat_Destroy(trackFormat); 72 trackFormat = nullptr; 73 } 74 75 if (sourceFormat != nullptr) { 76 OH_AVFormat_Destroy(sourceFormat); 77 sourceFormat = nullptr; 78 } 79 80 if (memory != nullptr) { 81 OH_AVMemory_Destroy(memory); 82 memory = nullptr; 83 } 84 if (source != nullptr) { 85 OH_AVSource_Destroy(source); 86 source = nullptr; 87 } 88 if (demuxer != nullptr) { 89 OH_AVDemuxer_Destroy(demuxer); 90 demuxer = nullptr; 91 } 92 93 for (int i = 0; i < g_maxThread; i++) { 94 if (demuxer_list[i] != nullptr) { 95 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 96 demuxer_list[i] = nullptr; 97 } 98 99 if (source_list[i] != nullptr) { 100 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 101 source_list[i] = nullptr; 102 } 103 if (memory_list[i] != nullptr) { 104 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 105 memory_list[i] = nullptr; 106 } 107 std::cout << i << " finish Destroy!!!!" << std::endl; 108 109 close(g_fdList[i]); 110 } 111} 112} // namespace Media 113} // namespace OHOS 114 115using namespace std; 116using namespace OHOS; 117using namespace OHOS::Media; 118using namespace testing::ext; 119namespace { 120static int64_t GetFileSize(const char *fileName) 121{ 122 int64_t fileSize = 0; 123 if (fileName != nullptr) { 124 struct stat fileStatus {}; 125 if (stat(fileName, &fileStatus) == 0) { 126 fileSize = static_cast<int64_t>(fileStatus.st_size); 127 } 128 } 129 return fileSize; 130} 131 132void DemuxFunc(int i, int loop) 133{ 134 bool audioIsEnd = false; 135 bool videoIsEnd = false; 136 OH_AVCodecBufferAttr attr; 137 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer_list[i], 0)); 138 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer_list[i], 1)); 139 while (!audioIsEnd || !videoIsEnd) { 140 for (int32_t index = 0; index < g_track; index++) { 141 if ((audioIsEnd && (index == MEDIA_TYPE_AUD)) || (videoIsEnd && (index == MEDIA_TYPE_VID))) { 142 continue; 143 } 144 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer_list[i], index, memory_list[i], &attr)); 145 146 if ((index == MEDIA_TYPE_AUD) && (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS)) { 147 audioIsEnd = true; 148 } 149 if ((index == MEDIA_TYPE_VID) && (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS)) { 150 videoIsEnd = true; 151 } 152 } 153 } 154} 155 156static void SetAudioValue(OH_AVCodecBufferAttr attr, bool &audioIsEnd, int &audioFrame) 157{ 158 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 159 audioIsEnd = true; 160 cout << audioFrame << " audio is end !!!!!!!!!!!!!!!" << endl; 161 } else { 162 audioFrame++; 163 } 164} 165 166static void SetVideoValue(OH_AVCodecBufferAttr attr, bool &videoIsEnd, int &videoFrame) 167{ 168 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 169 videoIsEnd = true; 170 cout << videoFrame << " video is end !!!!!!!!!!!!!!!" << endl; 171 } else { 172 videoFrame++; 173 cout << "video track !!!!!" << endl; 174 } 175} 176 177/** 178 * @tc.number : DEMUXER_RELI_1000 179 * @tc.name : create 16 instances create-destory 180 * @tc.desc : function test 181 */ 182HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_1000, TestSize.Level3) 183{ 184 int len = 256; 185 int num = 0; 186 vector<std::thread> vecThread; 187 for (int i = 0; i < g_maxThread; i++) { 188 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 189 char file[256] = {}; 190 sprintf_s(file, len, "/data/test/media/16/%d_video_audio.mp4", i); 191 g_fdList[i] = open(file, O_RDONLY); 192 int64_t size = GetFileSize(file); 193 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 194 195 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 196 ASSERT_NE(source_list[i], nullptr); 197 198 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 199 ASSERT_NE(demuxer_list[i], nullptr); 200 vecThread.emplace_back(DemuxFunc, i, num); 201 } 202 for (auto &val : vecThread) { 203 val.join(); 204 } 205} 206 207/** 208 * @tc.number : DEMUXER_RELI_0200 209 * @tc.name : create 16 instances repeat create-destory 210 * @tc.desc : function test 211 */ 212HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_0200, TestSize.Level3) 213{ 214 int num = 0; 215 int len = 256; 216 while (num < 10) { 217 num++; 218 vector<std::thread> vecThread; 219 for (int i = 0; i < g_maxThread; i++) { 220 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 221 char file[256] = {}; 222 sprintf_s(file, len, "/data/test/media/16/%d_video_audio.mp4", i); 223 g_fdList[i] = open(file, O_RDONLY); 224 int64_t size = GetFileSize(file); 225 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 226 227 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 228 ASSERT_NE(source_list[i], nullptr); 229 230 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 231 ASSERT_NE(demuxer_list[i], nullptr); 232 vecThread.emplace_back(DemuxFunc, i, num); 233 } 234 for (auto &val : vecThread) { 235 val.join(); 236 } 237 238 for (int i = 0; i < g_maxThread; i++) { 239 if (demuxer_list[i] != nullptr) { 240 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 241 demuxer_list[i] = nullptr; 242 } 243 244 if (source_list[i] != nullptr) { 245 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 246 source_list[i] = nullptr; 247 } 248 if (memory_list[i] != nullptr) { 249 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 250 memory_list[i] = nullptr; 251 } 252 std::cout << i << " finish Destroy!!!!" << std::endl; 253 254 close(g_fdList[i]); 255 } 256 cout << "num: " << num << endl; 257 } 258} 259 260/** 261 * @tc.number : DEMUXER_RELI_0300 262 * @tc.name : create 17 instances,17 failed 263 * @tc.desc : function test 264 */ 265HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_0300, TestSize.Level3) 266{ 267 int num = 0; 268 int len = 256; 269 int64_t size = 0; 270 vector<std::thread> vecThread; 271 for (int i = 0; i < g_maxThread; i++) { 272 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 273 char file[256] = {}; 274 sprintf_s(file, len, "/data/test/media/16/%d_video_audio.mp4", i); 275 g_fdList[i] = open(file, O_RDONLY); 276 size = GetFileSize(file); 277 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 278 279 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 280 ASSERT_NE(source_list[i], nullptr); 281 282 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 283 ASSERT_NE(demuxer_list[i], nullptr); 284 vecThread.emplace_back(DemuxFunc, i, num); 285 } 286 for (auto &val : vecThread) { 287 val.join(); 288 } 289 290 source = OH_AVSource_CreateWithFD(g_fdList[15], 0, size); 291 ASSERT_EQ(source, nullptr); 292 demuxer = OH_AVDemuxer_CreateWithSource(source); 293 ASSERT_EQ(demuxer, nullptr); 294} 295 296/** 297 * @tc.number : DEMUXER_RELI_0400 298 * @tc.name : one instance repeat create destory 299 * @tc.desc : function test 300 */ 301HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_0400, TestSize.Level0) 302{ 303 int num = 0; 304 OH_AVCodecBufferAttr attr; 305 306 const char *file = "/data/test/media/01_video_audio.mp4"; 307 bool audioIsEnd = false; 308 bool videoIsEnd = false; 309 310 int fd = open(file, O_RDONLY); 311 int64_t size = GetFileSize(file); 312 cout << file << "----------------------" << fd << "---------" << size << endl; 313 num++; 314 cout << num << endl; 315 source = OH_AVSource_CreateWithFD(fd, 0, size); 316 ASSERT_NE(source, nullptr); 317 318 demuxer = OH_AVDemuxer_CreateWithSource(source); 319 ASSERT_NE(demuxer, nullptr); 320 321 for (int32_t index = 0; index < 2; index++) { 322 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 323 } 324 while (!audioIsEnd || !videoIsEnd) { 325 for (int32_t index = 0; index < 2; index++) { 326 327 if ((audioIsEnd && (index == MEDIA_TYPE_AUD)) || (videoIsEnd && (index == MEDIA_TYPE_VID))) { 328 continue; 329 } 330 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 331 332 if ((index == MEDIA_TYPE_AUD) && (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS)) { 333 audioIsEnd = true; 334 cout << " audio is end !!!!!!!!!!!!!!!" << endl; 335 } 336 if ((index == MEDIA_TYPE_VID) && (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS)) { 337 videoIsEnd = true; 338 cout << " video is end !!!!!!!!!!!!!!!" << endl; 339 } 340 } 341 } 342 if (source != nullptr) { 343 OH_AVSource_Destroy(source); 344 source = nullptr; 345 } 346 if (demuxer != nullptr) { 347 OH_AVDemuxer_Destroy(demuxer); 348 demuxer = nullptr; 349 } 350 close(fd); 351} 352 353/** 354 * @tc.number : DEMUXER_RELI_0500 355 * @tc.name : one instance demux long file 356 * @tc.desc : function test 357 */ 358HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_0500, TestSize.Level3) 359{ 360 int num = 0; 361 OH_AVCodecBufferAttr attr; 362 363 const char *file = "/data/test/media/long.mp4"; 364 365 bool audioIsEnd = false; 366 bool videoIsEnd = false; 367 int audioFrame = 0; 368 int videoFrame = 0; 369 370 int fd = open(file, O_RDONLY); 371 int64_t size = GetFileSize(file); 372 cout << file << "----------------------" << fd << "---------" << size << endl; 373 num++; 374 cout << num << endl; 375 source = OH_AVSource_CreateWithFD(fd, 0, size); 376 ASSERT_NE(source, nullptr); 377 378 demuxer = OH_AVDemuxer_CreateWithSource(source); 379 ASSERT_NE(demuxer, nullptr); 380 381 for (int32_t index = 0; index < 2; index++) { 382 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 383 } 384 while (!audioIsEnd || !videoIsEnd) { 385 for (int32_t index = 0; index < 2; index++) { 386 if ((audioIsEnd && (index == MEDIA_TYPE_AUD)) || (videoIsEnd && (index == MEDIA_TYPE_VID))) { 387 continue; 388 } 389 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 390 391 if (index == MEDIA_TYPE_AUD) { 392 SetAudioValue(attr, audioIsEnd, audioFrame); 393 } else if (index == MEDIA_TYPE_VID) { 394 SetVideoValue(attr, videoIsEnd, videoFrame); 395 } 396 } 397 } 398 close(fd); 399} 400 401/** 402 * @tc.number : DEMUXER_RELI_0100 403 * @tc.name : OH_AVSource_CreateWithURI Repeat Call 404 * @tc.desc : api test 405 */ 406HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_0100, TestSize.Level2) 407{ 408 OH_AVSource *source1 = OH_AVSource_CreateWithURI(const_cast<char *>(URI1)); 409 cout << URI1 << "-----------------------" << endl; 410 ASSERT_NE(source1, nullptr); 411 OH_AVSource *source2 = OH_AVSource_CreateWithURI(const_cast<char *>(URI2)); 412 cout << URI2 << "-----------------------" << endl; 413 ASSERT_NE(source2, nullptr); 414 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source1)); 415 source1 = nullptr; 416 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source2)); 417 source2 = nullptr; 418} 419 420/** 421 * @tc.number : DEMUXER_RELI_4400 422 * @tc.name : OH_AVSource_CreateWithURI with unSupported rtsp uri 423 * @tc.desc : api test 424 */ 425HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_4400, TestSize.Level2) 426{ 427 const char *uri = "rtp://192.168.3.11:12345"; 428 cout << uri << "------" << endl; 429 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 430 ASSERT_EQ(source, nullptr); 431} 432 433/** 434 * @tc.number : DEMUXER_RELI_4500 435 * @tc.name : OH_AVSource_CreateWithURI with unSupported rtp uri 436 * @tc.desc : api test 437 */ 438HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_4500, TestSize.Level2) 439{ 440 const char *uri = "rtp://192.168.3.11:12345"; 441 cout << uri << "------" << endl; 442 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 443 ASSERT_EQ(source, nullptr); 444} 445 446/** 447 * @tc.number : DEMUXER_RELI_4600 448 * @tc.name : OH_AVSource_CreateWithURI with invalid uri 449 * @tc.desc : api test 450 */ 451HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_4600, TestSize.Level2) 452{ 453 const char *uri = "https://media.w3.org/2010/05/sinte/trailer.mp4"; 454 cout << uri << "------" << endl; 455 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 456 ASSERT_EQ(source, nullptr); 457} 458 459/** 460 * @tc.number : DEMUXER_RELI_4700 461 * @tc.name : OH_AVSource_CreateWithURI with https 462 * @tc.desc : api test 463 */ 464HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_4700, TestSize.Level2) 465{ 466 OH_AVCodecBufferAttr attr; 467 bool audioIsEnd = false; 468 bool videoIsEnd = false; 469 int audioFrame = 0; 470 int videoFrame = 0; 471 int tarckType = 0; 472 const char *uri = "https://media.w3.org/2010/05/sintel/trailer.mp4"; 473 cout << uri << "------" << endl; 474 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 475 ASSERT_NE(source, nullptr); 476 477 demuxer = OH_AVDemuxer_CreateWithSource(source); 478 ASSERT_NE(demuxer, nullptr); 479 480 sourceFormat = OH_AVSource_GetSourceFormat(source); 481 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 482 ASSERT_EQ(2, g_trackCount); 483 for (int32_t index = 0; index < g_trackCount; index++) { 484 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 485 } 486 while (!audioIsEnd || !videoIsEnd) { 487 for (int32_t index = 0; index < g_trackCount; index++) { 488 489 trackFormat = OH_AVSource_GetTrackFormat(source, index); 490 ASSERT_NE(trackFormat, nullptr); 491 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 492 OH_AVFormat_Destroy(trackFormat); 493 trackFormat = nullptr; 494 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 495 continue; 496 } 497 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 498 499 if (tarckType == MEDIA_TYPE_AUD) { 500 SetAudioValue(attr, audioIsEnd, audioFrame); 501 } else if (tarckType == MEDIA_TYPE_VID) { 502 SetVideoValue(attr, videoIsEnd, videoFrame); 503 } 504 } 505 } 506} 507 508/** 509 * @tc.number : DEMUXER_RELI_4800 510 * @tc.name : OH_AVSource_CreateWithURI with not supported track 511 * @tc.desc : api test 512 */ 513HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_4800, TestSize.Level2) 514{ 515 const char *uri = "http://clips.vorwaerts-gmbh.de/big_buck_bunny.mp4"; 516 cout << uri << "------" << endl; 517 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 518 ASSERT_NE(source, nullptr); 519 520 demuxer = OH_AVDemuxer_CreateWithSource(source); 521 ASSERT_NE(demuxer, nullptr); 522 523 sourceFormat = OH_AVSource_GetSourceFormat(source); 524 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 525 ASSERT_EQ(4, g_trackCount); 526 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 527 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 1)); 528 ASSERT_NE(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 2)); 529 ASSERT_NE(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 3)); 530} 531 532/** 533 * @tc.number : DEMUXER_RELI_4900 534 * @tc.name : create source with uri 535 * @tc.desc : function test 536 */ 537HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_4900, TestSize.Level0) 538{ 539 OH_AVCodecBufferAttr attr; 540 bool audioIsEnd = false; 541 int audioFrame = 0; 542 543 const char *uri = "http://192.168.3.11:8080/share/audio/MP3_48000_1.mp3"; 544 cout << uri << "------" << endl; 545 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 546 ASSERT_NE(source, nullptr); 547 548 demuxer = OH_AVDemuxer_CreateWithSource(source); 549 ASSERT_NE(demuxer, nullptr); 550 551 sourceFormat = OH_AVSource_GetSourceFormat(source); 552 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 553 ASSERT_EQ(1, g_trackCount); 554 555 for (int32_t index = 0; index < g_trackCount; index++) { 556 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 557 } 558 int keyCount = 0; 559 while (!audioIsEnd) { 560 for (int32_t index = 0; index < g_trackCount; index++) { 561 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 562 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 563 audioIsEnd = true; 564 cout << audioFrame << " audio is end !!!!!!!!!!!!!!!" << endl; 565 continue; 566 } 567 568 audioFrame++; 569 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 570 keyCount++; 571 } 572 } 573 } 574 ASSERT_EQ(audioFrame, 9150); 575 ASSERT_EQ(keyCount, 9150); 576} 577 578/** 579 * @tc.number : DEMUXER_RELI_0500 580 * @tc.name : create source with uri,aac 581 * @tc.desc : function test 582 */ 583HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5000, TestSize.Level0) 584{ 585 OH_AVCodecBufferAttr attr; 586 bool isEnd = false; 587 588 const char *uri = "http://192.168.3.11:8080/share/audio/AAC_48000_1.aac"; 589 cout << uri << "------" << endl; 590 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 591 ASSERT_NE(source, nullptr); 592 593 demuxer = OH_AVDemuxer_CreateWithSource(source); 594 ASSERT_NE(demuxer, nullptr); 595 596 sourceFormat = OH_AVSource_GetSourceFormat(source); 597 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 598 599 for (int32_t index = 0; index < g_trackCount; index++) { 600 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 601 } 602 603 int audioFrame = 0; 604 int keyCount = 0; 605 while (!isEnd) { 606 for (int32_t index = 0; index < g_trackCount; index++) { 607 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 608 cout << attr.size << "size---------------pts:" << attr.pts << endl; 609 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 610 isEnd = true; 611 cout << "isend !!!!!!!!!!!!!!!" << endl; 612 continue; 613 } 614 615 audioFrame++; 616 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 617 keyCount++; 618 } 619 } 620 } 621 ASSERT_EQ(audioFrame, 9457); 622 ASSERT_EQ(keyCount, 9457); 623} 624 625/** 626 * @tc.number : DEMUXER_RELI_5100 627 * @tc.name : create source with uri,flac 628 * @tc.desc : function test 629 */ 630HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5100, TestSize.Level0) 631{ 632 OH_AVCodecBufferAttr attr; 633 bool isEnd = false; 634 635 const char *uri = "http://192.168.3.11:8080/share/audio/FLAC_48000_1.flac"; 636 cout << uri << "------" << endl; 637 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 638 ASSERT_NE(source, nullptr); 639 640 demuxer = OH_AVDemuxer_CreateWithSource(source); 641 ASSERT_NE(demuxer, nullptr); 642 643 sourceFormat = OH_AVSource_GetSourceFormat(source); 644 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 645 646 for (int32_t index = 0; index < g_trackCount; index++) { 647 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 648 } 649 650 int audioFrame = 0; 651 int keyCount = 0; 652 while (!isEnd) { 653 for (int32_t index = 0; index < g_trackCount; index++) { 654 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 655 cout << attr.size << "size---------------pts:" << attr.pts << endl; 656 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 657 isEnd = true; 658 cout << "isend !!!!!!!!!!!!!!!" << endl; 659 continue; 660 } 661 662 audioFrame++; 663 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 664 keyCount++; 665 } 666 } 667 } 668 ASSERT_EQ(audioFrame, 2288); 669 ASSERT_EQ(keyCount, 2288); 670} 671 672/** 673 * @tc.number : DEMUXER_RELI_5200 674 * @tc.name : create source with uri,m4a 675 * @tc.desc : function test 676 */ 677HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5200, TestSize.Level0) 678{ 679 OH_AVCodecBufferAttr attr; 680 bool isEnd = false; 681 682 const char *uri = "http://192.168.3.11:8080/share/audio/M4A_48000_1.m4a"; 683 cout << uri << "------" << endl; 684 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 685 ASSERT_NE(source, nullptr); 686 687 demuxer = OH_AVDemuxer_CreateWithSource(source); 688 ASSERT_NE(demuxer, nullptr); 689 690 sourceFormat = OH_AVSource_GetSourceFormat(source); 691 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 692 693 for (int32_t index = 0; index < g_trackCount; index++) { 694 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 695 } 696 697 int audioFrame = 0; 698 int keyCount = 0; 699 while (!isEnd) { 700 for (int32_t index = 0; index < g_trackCount; index++) { 701 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 702 cout << attr.size << "size---------------pts:" << attr.pts << endl; 703 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 704 isEnd = true; 705 cout << "isend !!!!!!!!!!!!!!!" << endl; 706 continue; 707 } 708 709 audioFrame++; 710 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 711 keyCount++; 712 } 713 } 714 } 715 ASSERT_EQ(audioFrame, 10293); 716 ASSERT_EQ(keyCount, 10293); 717} 718 719/** 720 * @tc.number : DEMUXER_RELI_5300 721 * @tc.name : create source with uri,mp3 722 * @tc.desc : function test 723 */ 724HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5300, TestSize.Level0) 725{ 726 OH_AVCodecBufferAttr attr; 727 bool isEnd = false; 728 729 const char *uri = "http://192.168.3.11:8080/share/audio/MP3_48000_1.mp3"; 730 cout << uri << "------" << endl; 731 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 732 ASSERT_NE(source, nullptr); 733 734 demuxer = OH_AVDemuxer_CreateWithSource(source); 735 ASSERT_NE(demuxer, nullptr); 736 737 sourceFormat = OH_AVSource_GetSourceFormat(source); 738 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 739 740 for (int32_t index = 0; index < g_trackCount; index++) { 741 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 742 } 743 744 int audioFrame = 0; 745 int keyCount = 0; 746 while (!isEnd) { 747 for (int32_t index = 0; index < g_trackCount; index++) { 748 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 749 cout << attr.size << "size---------------pts:" << attr.pts << endl; 750 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 751 isEnd = true; 752 cout << "isend !!!!!!!!!!!!!!!" << endl; 753 continue; 754 } 755 756 audioFrame++; 757 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 758 keyCount++; 759 } 760 } 761 } 762 ASSERT_EQ(audioFrame, 9150); 763 ASSERT_EQ(keyCount, 9150); 764} 765 766/** 767 * @tc.number : DEMUXER_RELI_5400 768 * @tc.name : create source with uri,ogg 769 * @tc.desc : function test 770 */ 771HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5400, TestSize.Level0) 772{ 773 OH_AVCodecBufferAttr attr; 774 bool isEnd = false; 775 776 const char *uri = "http://192.168.3.11:8080/share/audio/OGG_48000_1.ogg"; 777 cout << uri << "------" << endl; 778 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 779 ASSERT_NE(source, nullptr); 780 781 demuxer = OH_AVDemuxer_CreateWithSource(source); 782 ASSERT_NE(demuxer, nullptr); 783 784 sourceFormat = OH_AVSource_GetSourceFormat(source); 785 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 786 787 for (int32_t index = 0; index < g_trackCount; index++) { 788 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 789 } 790 791 int audioFrame = 0; 792 int keyCount = 0; 793 while (!isEnd) { 794 for (int32_t index = 0; index < g_trackCount; index++) { 795 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 796 cout << attr.size << "size---------------pts:" << attr.pts << endl; 797 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 798 isEnd = true; 799 cout << "isend !!!!!!!!!!!!!!!" << endl; 800 continue; 801 } 802 803 audioFrame++; 804 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 805 keyCount++; 806 } 807 } 808 } 809 ASSERT_EQ(audioFrame, 11439); 810 ASSERT_EQ(keyCount, 11439); 811} 812 813/** 814 * @tc.number : DEMUXER_RELI_5500 815 * @tc.name : create source with uri,wav 816 * @tc.desc : function test 817 */ 818HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5500, TestSize.Level0) 819{ 820 OH_AVCodecBufferAttr attr; 821 bool isEnd = false; 822 823 const char *uri = "http://192.168.3.11:8080/share/audio/wav_48000_1.wav"; 824 cout << uri << "------" << endl; 825 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 826 ASSERT_NE(source, nullptr); 827 828 demuxer = OH_AVDemuxer_CreateWithSource(source); 829 ASSERT_NE(demuxer, nullptr); 830 831 sourceFormat = OH_AVSource_GetSourceFormat(source); 832 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 833 834 for (int32_t index = 0; index < g_trackCount; index++) { 835 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 836 } 837 838 int audioFrame = 0; 839 int keyCount = 0; 840 while (!isEnd) { 841 for (int32_t index = 0; index < g_trackCount; index++) { 842 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 843 cout << attr.size << "size---------------pts:" << attr.pts << endl; 844 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 845 isEnd = true; 846 cout << "isend !!!!!!!!!!!!!!!" << endl; 847 continue; 848 } 849 850 audioFrame++; 851 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 852 keyCount++; 853 } 854 } 855 } 856 ASSERT_EQ(audioFrame, 5146); 857 ASSERT_EQ(keyCount, 5146); 858} 859 860/** 861 * @tc.number : DEMUXER_RELI_5600 862 * @tc.name : create source with uri,mp4 863 * @tc.desc : function test 864 */ 865HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5600, TestSize.Level0) 866{ 867 OH_AVCodecBufferAttr attr; 868 bool audioIsEnd = false; 869 bool videoIsEnd = false; 870 int audioFrame = 0; 871 int videoFrame = 0; 872 int tarckType = 0; 873 const char *uri = "http://192.168.3.11:8080/share/01_video_audio.mp4"; 874 cout << uri << "------" << endl; 875 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 876 ASSERT_NE(source, nullptr); 877 878 demuxer = OH_AVDemuxer_CreateWithSource(source); 879 ASSERT_NE(demuxer, nullptr); 880 881 sourceFormat = OH_AVSource_GetSourceFormat(source); 882 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 883 ASSERT_EQ(2, g_trackCount); 884 for (int32_t index = 0; index < g_trackCount; index++) { 885 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 886 } 887 while (!audioIsEnd || !videoIsEnd) { 888 for (int32_t index = 0; index < g_trackCount; index++) { 889 890 trackFormat = OH_AVSource_GetTrackFormat(source, index); 891 ASSERT_NE(trackFormat, nullptr); 892 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 893 OH_AVFormat_Destroy(trackFormat); 894 trackFormat = nullptr; 895 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 896 continue; 897 } 898 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 899 900 if (tarckType == MEDIA_TYPE_AUD) { 901 SetAudioValue(attr, audioIsEnd, audioFrame); 902 } else if (tarckType == MEDIA_TYPE_VID) { 903 SetVideoValue(attr, videoIsEnd, videoFrame); 904 } 905 } 906 } 907} 908 909void CreateDemuxer(char *uri) 910{ 911 int two = 2; 912 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 913 ASSERT_NE(source, nullptr); 914 915 demuxer = OH_AVDemuxer_CreateWithSource(source); 916 ASSERT_NE(demuxer, nullptr); 917 918 sourceFormat = OH_AVSource_GetSourceFormat(source); 919 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 920 ASSERT_EQ(two, g_trackCount); 921 922 for (int32_t index = 0; index < g_trackCount; index++) { 923 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 924 } 925} 926 927/** 928 * @tc.number : DEMUXER_RELI_5700 929 * @tc.name : create source with uri,hvcc mp4 930 * @tc.desc : function test 931 */ 932HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5700, TestSize.Level0) 933{ 934 int tarckType = 0; 935 OH_AVCodecBufferAttr attr; 936 bool audioIsEnd = false; 937 bool videoIsEnd = false; 938 int audioFrame = 0; 939 int videoFrame = 0; 940 const char *uri = "http://192.168.3.11:8080/share/hvcc_1920x1080_60.mp4"; 941 cout << uri << "------" << endl; 942 CreateDemuxer(const_cast<char *>(uri)); 943 int aKeyCount = 0; 944 int vKeyCount = 0; 945 while (!audioIsEnd || !videoIsEnd) { 946 for (int32_t index = 0; index < g_trackCount; index++) { 947 948 trackFormat = OH_AVSource_GetTrackFormat(source, index); 949 ASSERT_NE(trackFormat, nullptr); 950 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 951 OH_AVFormat_Destroy(trackFormat); 952 trackFormat = nullptr; 953 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 954 continue; 955 } 956 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 957 958 if (tarckType == MEDIA_TYPE_AUD) { 959 SetAudioValue(attr, audioIsEnd, audioFrame); 960 } else if (tarckType == MEDIA_TYPE_VID) { 961 SetVideoValue(attr, videoIsEnd, videoFrame); 962 } 963 964 if (tarckType == MEDIA_TYPE_AUD && attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 965 aKeyCount++; 966 } else if (tarckType == MEDIA_TYPE_VID && attr.flags & 967 OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 968 vKeyCount++; 969 } 970 } 971 } 972 ASSERT_EQ(audioFrame, 433); 973 ASSERT_EQ(videoFrame, 602); 974 ASSERT_EQ(aKeyCount, 433); 975 ASSERT_EQ(vKeyCount, 3); 976} 977 978/** 979 * @tc.number : DEMUXER_RELI_5800 980 * @tc.name : create source with uri,wav 981 * @tc.desc : function test 982 */ 983HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5800, TestSize.Level0) 984{ 985 int tarckType = 0; 986 OH_AVCodecBufferAttr attr; 987 bool audioIsEnd = false; 988 bool videoIsEnd = false; 989 int audioFrame = 0; 990 int videoFrame = 0; 991 992 const char *uri = "http://192.168.3.11:8080/share/avcc_10sec.mp4"; 993 cout << uri << "------" << endl; 994 CreateDemuxer(const_cast<char *>(uri)); 995 while (!audioIsEnd || !videoIsEnd) { 996 for (int32_t index = 0; index < g_trackCount; index++) { 997 998 trackFormat = OH_AVSource_GetTrackFormat(source, index); 999 ASSERT_NE(trackFormat, nullptr); 1000 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1001 OH_AVFormat_Destroy(trackFormat); 1002 trackFormat = nullptr; 1003 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1004 continue; 1005 } 1006 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1007 1008 if (tarckType == MEDIA_TYPE_AUD) { 1009 SetAudioValue(attr, audioIsEnd, audioFrame); 1010 } else if (tarckType == MEDIA_TYPE_VID) { 1011 SetVideoValue(attr, videoIsEnd, videoFrame); 1012 } 1013 } 1014 } 1015 ASSERT_EQ(audioFrame, 431); 1016 ASSERT_EQ(videoFrame, 600); 1017} 1018 1019/** 1020 * @tc.number : DEMUXER_RELI_5900 1021 * @tc.name : create source with uri,wav 1022 * @tc.desc : function test 1023 */ 1024HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_5900, TestSize.Level0) 1025{ 1026 int tarckType = 0; 1027 OH_AVCodecBufferAttr attr; 1028 bool audioIsEnd = false; 1029 bool videoIsEnd = false; 1030 int audioFrame = 0; 1031 int videoFrame = 0; 1032 const char *uri = "http://192.168.3.11:8080/share/ts_video.ts"; 1033 cout << uri << "------" << endl; 1034 CreateDemuxer(const_cast<char *>(uri)); 1035 while (!audioIsEnd || !videoIsEnd) { 1036 for (int32_t index = 0; index < g_trackCount; index++) { 1037 1038 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1039 ASSERT_NE(trackFormat, nullptr); 1040 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1041 OH_AVFormat_Destroy(trackFormat); 1042 trackFormat = nullptr; 1043 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1044 continue; 1045 } 1046 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1047 1048 if (tarckType == MEDIA_TYPE_AUD) { 1049 SetAudioValue(attr, audioIsEnd, audioFrame); 1050 } else if (tarckType == MEDIA_TYPE_VID) { 1051 SetVideoValue(attr, videoIsEnd, videoFrame); 1052 } 1053 } 1054 } 1055 ASSERT_EQ(audioFrame, 384); 1056 ASSERT_EQ(videoFrame, 602); 1057} 1058 1059/** 1060 * @tc.number : DEMUXER_RELI_6000 1061 * @tc.name : create source with uri,wav 1062 * @tc.desc : function test 1063 */ 1064HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6000, TestSize.Level0) 1065{ 1066 const char *uri = "http://192.168.3.11:8080/share/zero_track.mp4"; 1067 cout << uri << "------" << endl; 1068 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1069 ASSERT_NE(source, nullptr); 1070 1071 demuxer = OH_AVDemuxer_CreateWithSource(source); 1072 ASSERT_NE(demuxer, nullptr); 1073 1074 sourceFormat = OH_AVSource_GetSourceFormat(source); 1075 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1076 ASSERT_EQ(g_trackCount, 0); 1077 1078 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1079} 1080 1081/** 1082 * @tc.number : DEMUXER_RELI_6100 1083 * @tc.name : create source with uri 1084 * @tc.desc : reliable test 1085 */ 1086HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6100, TestSize.Level0) 1087{ 1088 int num = 0; 1089 OH_AVCodecBufferAttr attr; 1090 const char *uri = "http://192.168.3.11:8080/share/avcc_10sec.mp4"; 1091 cout << uri << "------" << endl; 1092 cout<<"num: "<<num<<endl; 1093 int tarckType = 0; 1094 bool audioIsEnd = false; 1095 bool videoIsEnd = false; 1096 int audioFrame = 0; 1097 int videoFrame = 0; 1098 CreateDemuxer(const_cast<char *>(uri)); 1099 while (!audioIsEnd || !videoIsEnd) { 1100 for (int32_t index = 0; index < g_trackCount; index++) { 1101 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1102 ASSERT_NE(trackFormat, nullptr); 1103 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1104 OH_AVFormat_Destroy(trackFormat); 1105 trackFormat = nullptr; 1106 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1107 continue; 1108 } 1109 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1110 1111 if (tarckType == MEDIA_TYPE_AUD) { 1112 SetAudioValue(attr, audioIsEnd, audioFrame); 1113 } else if (tarckType == MEDIA_TYPE_VID) { 1114 SetVideoValue(attr, videoIsEnd, videoFrame); 1115 } 1116 } 1117 } 1118 ASSERT_EQ(audioFrame, 431); 1119 ASSERT_EQ(videoFrame, 600); 1120 num++; 1121} 1122 1123/** 1124 * @tc.number : DEMUXER_RELI_6200 1125 * @tc.name : create source with uri 1126 * @tc.desc : reliable test 1127 */ 1128HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6200, TestSize.Level3) 1129{ 1130 int num = 0; 1131 OH_AVCodecBufferAttr attr; 1132 const char *uri = "https://media.w3.org/2010/05/sintel/trailer.mp4"; 1133 cout << uri << "------" << endl; 1134 cout<<"num: "<<num<<endl; 1135 int tarckType = 0; 1136 bool audioIsEnd = false; 1137 bool videoIsEnd = false; 1138 int audioFrame = 0; 1139 int videoFrame = 0; 1140 CreateDemuxer(const_cast<char *>(uri)); 1141 while (!audioIsEnd || !videoIsEnd) { 1142 for (int32_t index = 0; index < g_trackCount; index++) { 1143 1144 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1145 ASSERT_NE(trackFormat, nullptr); 1146 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1147 OH_AVFormat_Destroy(trackFormat); 1148 trackFormat = nullptr; 1149 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1150 continue; 1151 } 1152 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1153 1154 if (tarckType == MEDIA_TYPE_AUD) { 1155 SetAudioValue(attr, audioIsEnd, audioFrame); 1156 } else if (tarckType == MEDIA_TYPE_VID) { 1157 SetVideoValue(attr, videoIsEnd, videoFrame); 1158 } 1159 } 1160 } 1161 num++; 1162} 1163 1164/** 1165 * @tc.number : DEMUXER_RELI_6300 1166 * @tc.name : create 16 instances create-destory 1167 * @tc.desc : function test 1168 */ 1169HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6300, TestSize.Level3) 1170{ 1171 int num = 0; 1172 while (num < 5) { 1173 num++; 1174 vector<std::thread> vecThread; 1175 // "https://media.w3.org/2010/05/sintel/trailer.mp4" 1176 const char *uri = "http://192.168.3.11:8080/share/avcc_10sec.mp4"; 1177 for (int i = 0; i < g_maxThread; i++) { 1178 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1179 cout << i << " uri: " << uri << endl; 1180 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1181 ASSERT_NE(source_list[i], nullptr); 1182 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1183 ASSERT_NE(demuxer_list[i], nullptr); 1184 vecThread.emplace_back(DemuxFunc, i, num); 1185 } 1186 for (auto &val : vecThread) { 1187 val.join(); 1188 } 1189 1190 for (int i = 0; i < g_maxThread; i++) { 1191 if (demuxer_list[i] != nullptr) { 1192 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1193 demuxer_list[i] = nullptr; 1194 } 1195 1196 if (source_list[i] != nullptr) { 1197 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1198 source_list[i] = nullptr; 1199 } 1200 if (memory_list[i] != nullptr) { 1201 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1202 memory_list[i] = nullptr; 1203 } 1204 std::cout << i << " finish Destroy!!!!" << std::endl; 1205 } 1206 cout << "num: " << num << endl; 1207 } 1208} 1209 1210/** 1211 * @tc.number : DEMUXER_RELI_6400 1212 * @tc.name : create source with uri,amr_nb 1213 * @tc.desc : function test 1214 */ 1215HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6400, TestSize.Level0) 1216{ 1217 OH_AVCodecBufferAttr attr; 1218 bool isEnd = false; 1219 const char *uri = "http://192.168.3.11:8080/share/amr_nb_8000_1.amr"; 1220 cout << uri << "------" << endl; 1221 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1222 ASSERT_NE(source, nullptr); 1223 demuxer = OH_AVDemuxer_CreateWithSource(source); 1224 ASSERT_NE(demuxer, nullptr); 1225 sourceFormat = OH_AVSource_GetSourceFormat(source); 1226 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1227 for (int32_t index = 0; index < g_trackCount; index++) { 1228 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 1229 } 1230 int audioFrame = 0; 1231 int keyCount = 0; 1232 while (!isEnd) { 1233 for (int32_t index = 0; index < g_trackCount; index++) { 1234 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1235 cout << attr.size << "size---------------pts:" << attr.pts << endl; 1236 if (attr.flags == OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1237 isEnd = true; 1238 cout << "isend !!!!!!!!!!!!!!!" << endl; 1239 continue; 1240 } 1241 audioFrame++; 1242 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 1243 keyCount++; 1244 } 1245 } 1246 } 1247 cout << "audioFrame:" << audioFrame << " keyCount:" << keyCount << endl; 1248 ASSERT_EQ(audioFrame, 1501); 1249 ASSERT_EQ(keyCount, 1501); 1250} 1251 1252/** 1253 * @tc.number : DEMUXER_RELI_6500 1254 * @tc.name : create source with uri,flac 1255 * @tc.desc : function test 1256 */ 1257HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6500, TestSize.Level0) 1258{ 1259 OH_AVCodecBufferAttr attr; 1260 bool isEnd = false; 1261 const char *uri = "http://192.168.3.11:8080/share/amr_wb_16000_1.amr"; 1262 cout << uri << "------" << endl; 1263 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1264 ASSERT_NE(source, nullptr); 1265 demuxer = OH_AVDemuxer_CreateWithSource(source); 1266 ASSERT_NE(demuxer, nullptr); 1267 sourceFormat = OH_AVSource_GetSourceFormat(source); 1268 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1269 for (int32_t index = 0; index < g_trackCount; index++) { 1270 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 1271 } 1272 int audioFrame = 0; 1273 int keyCount = 0; 1274 while (!isEnd) { 1275 for (int32_t index = 0; index < g_trackCount; index++) { 1276 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1277 cout << attr.size << "size---------------pts:" << attr.pts << endl; 1278 if (attr.flags == OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1279 isEnd = true; 1280 cout << "isend !!!!!!!!!!!!!!!" << endl; 1281 continue; 1282 } 1283 1284 audioFrame++; 1285 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 1286 keyCount++; 1287 } 1288 } 1289 } 1290 cout << "audioFrame:" << audioFrame << " keyCount:" << keyCount << endl; 1291 ASSERT_EQ(audioFrame, 1500); 1292 ASSERT_EQ(keyCount, 1500); 1293} 1294 1295/** 1296 * @tc.number : DEMUXER_RELI_6600 1297 * @tc.name : create source with uri,hevc ts 1298 * @tc.desc : function test 1299 */ 1300HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6600, TestSize.Level0) 1301{ 1302 OH_AVCodecBufferAttr attr; 1303 const char *uri = "http://192.168.3.11:8080/share/hevc_v_a.ts"; 1304 cout << uri << "------" << endl; 1305 int tarckType = 0; 1306 bool audioIsEnd = false; 1307 bool videoIsEnd = false; 1308 int audioFrame = 0; 1309 int videoFrame = 0; 1310 CreateDemuxer(const_cast<char *>(uri)); 1311 while (!audioIsEnd || !videoIsEnd) { 1312 for (int32_t index = 0; index < g_trackCount; index++) { 1313 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1314 ASSERT_NE(trackFormat, nullptr); 1315 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1316 OH_AVFormat_Destroy(trackFormat); 1317 trackFormat = nullptr; 1318 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1319 continue; 1320 } 1321 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1322 if (tarckType == MEDIA_TYPE_AUD) { 1323 SetAudioValue(attr, audioIsEnd, audioFrame); 1324 } else if (tarckType == MEDIA_TYPE_VID) { 1325 SetVideoValue(attr, videoIsEnd, videoFrame); 1326 } 1327 } 1328 } 1329 ASSERT_EQ(audioFrame, 384); 1330 ASSERT_EQ(videoFrame, 602); 1331} 1332 1333/** 1334 * @tc.number : DEMUXER_RELI_6700 1335 * @tc.name : create 16 instances create-destory 1336 * @tc.desc : function test 1337 */ 1338HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6700, TestSize.Level3) 1339{ 1340 int num = 0; 1341 while (num < 5) { 1342 num++; 1343 vector<std::thread> vecThread; 1344 const char *uri = "http://192.168.3.11:8080/share/hevc_v_a.ts"; 1345 for (int i = 0; i < g_maxThread; i++) { 1346 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1347 cout << i << " uri: " << uri << endl; 1348 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1349 ASSERT_NE(source_list[i], nullptr); 1350 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1351 ASSERT_NE(demuxer_list[i], nullptr); 1352 vecThread.emplace_back(DemuxFunc, i, num); 1353 } 1354 for (auto &val : vecThread) { 1355 val.join(); 1356 } 1357 for (int i = 0; i < g_maxThread; i++) { 1358 if (demuxer_list[i] != nullptr) { 1359 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1360 demuxer_list[i] = nullptr; 1361 } 1362 1363 if (source_list[i] != nullptr) { 1364 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1365 source_list[i] = nullptr; 1366 } 1367 if (memory_list[i] != nullptr) { 1368 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1369 memory_list[i] = nullptr; 1370 } 1371 std::cout << i << " finish Destroy!!!!" << std::endl; 1372 } 1373 cout << "num: " << num << endl; 1374 } 1375} 1376 1377/** 1378 * @tc.number : DEMUXER_RELI_6800 1379 * @tc.name : create 16 instances repeat create-destory 1380 * @tc.desc : function test 1381 */ 1382HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6800, TestSize.Level3) 1383{ 1384 int num = 0; 1385 int len = 256; 1386 while (num < 10) { 1387 num++; 1388 vector<std::thread> vecThread; 1389 for (int i = 0; i < g_maxThread; i++) { 1390 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1391 char file[256] = {}; 1392 sprintf_s(file, len, "/data/test/media/16/%d_hevc_v_a.ts", i); 1393 g_fdList[i] = open(file, O_RDONLY); 1394 int64_t size = GetFileSize(file); 1395 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 1396 1397 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 1398 ASSERT_NE(source_list[i], nullptr); 1399 1400 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1401 ASSERT_NE(demuxer_list[i], nullptr); 1402 vecThread.emplace_back(DemuxFunc, i, num); 1403 } 1404 for (auto &val : vecThread) { 1405 val.join(); 1406 } 1407 1408 for (int i = 0; i < g_maxThread; i++) { 1409 if (demuxer_list[i] != nullptr) { 1410 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1411 demuxer_list[i] = nullptr; 1412 } 1413 1414 if (source_list[i] != nullptr) { 1415 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1416 source_list[i] = nullptr; 1417 } 1418 if (memory_list[i] != nullptr) { 1419 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1420 memory_list[i] = nullptr; 1421 } 1422 std::cout << i << " finish Destroy!!!!" << std::endl; 1423 1424 close(g_fdList[i]); 1425 } 1426 cout << "num: " << num << endl; 1427 } 1428} 1429 1430/** 1431 * @tc.number : DEMUXER_RELI_6900 1432 * @tc.name : create source with uri,2 audio 1433 * @tc.desc : function test 1434 */ 1435HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_6900, TestSize.Level0) 1436{ 1437 int tarckType = 0; 1438 int auidoTrackCount = 2; 1439 OH_AVCodecBufferAttr attr; 1440 bool videoIsEnd = false; 1441 int videoFrame = 0; 1442 const char *uri = "http://192.168.3.11:8080/share/video_2audio.mp4"; 1443 CreateDemuxer(const_cast<char *>(uri)); 1444 int audioFrame[2] = {}; 1445 bool audioIsEnd = false; 1446 while (!audioIsEnd || !videoIsEnd) { 1447 for (int32_t index = 0; index < g_trackCount; index++) { 1448 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1449 ASSERT_NE(trackFormat, nullptr); 1450 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1451 OH_AVFormat_Destroy(trackFormat); 1452 trackFormat = nullptr; 1453 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1454 continue; 1455 } 1456 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1457 if (tarckType == MEDIA_TYPE_VID) { 1458 SetVideoValue(attr, videoIsEnd, videoFrame); 1459 } else if (tarckType == MEDIA_TYPE_AUD) { 1460 SetAudioValue(attr, audioIsEnd, audioFrame[index-1]); 1461 } 1462 } 1463 } 1464 for (int index = 0; index < auidoTrackCount; index++) { 1465 ASSERT_EQ(audioFrame[index], 433); 1466 } 1467 ASSERT_EQ(videoFrame, 602); 1468} 1469 1470/** 1471 * @tc.number : DEMUXER_RELI_7000 1472 * @tc.name : create 16 instances create-destory 1473 * @tc.desc : function test 1474 */ 1475HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7000, TestSize.Level3) 1476{ 1477 int num = 0; 1478 while (num < 10) { 1479 num++; 1480 vector<std::thread> vecThread; 1481 const char *uri = "http://192.168.3.11:8080/share/video_2audio.mp4"; 1482 for (int i = 0; i < g_maxThread; i++) { 1483 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1484 cout << i << " uri: " << uri << endl; 1485 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1486 ASSERT_NE(source_list[i], nullptr); 1487 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1488 ASSERT_NE(demuxer_list[i], nullptr); 1489 vecThread.emplace_back(DemuxFunc, i, num); 1490 } 1491 for (auto &val : vecThread) { 1492 val.join(); 1493 } 1494 for (int i = 0; i < g_maxThread; i++) { 1495 if (demuxer_list[i] != nullptr) { 1496 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1497 demuxer_list[i] = nullptr; 1498 } 1499 1500 if (source_list[i] != nullptr) { 1501 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1502 source_list[i] = nullptr; 1503 } 1504 if (memory_list[i] != nullptr) { 1505 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1506 memory_list[i] = nullptr; 1507 } 1508 std::cout << i << " finish Destroy!!!!" << std::endl; 1509 } 1510 cout << "num: " << num << endl; 1511 } 1512} 1513 1514static void SetAudioValue(OH_AVCodecBufferAttr attr, bool &audioIsEnd, int &audioFrame, int &aKeyCount) 1515{ 1516 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1517 audioIsEnd = true; 1518 cout << audioFrame << " audio is end !!!!!!!!!!!!!!!" << endl; 1519 } else { 1520 audioFrame++; 1521 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 1522 aKeyCount++; 1523 } 1524 } 1525} 1526 1527static void SetVideoValue(OH_AVCodecBufferAttr attr, bool &videoIsEnd, int &videoFrame, int &vKeyCount) 1528{ 1529 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1530 videoIsEnd = true; 1531 cout << videoFrame << " video is end !!!!!!!!!!!!!!!" << endl; 1532 } else { 1533 videoFrame++; 1534 cout << "video track !!!!!" << endl; 1535 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 1536 vKeyCount++; 1537 } 1538 } 1539} 1540 1541/** 1542 * @tc.number : DEMUXER_RELI_7100 1543 * @tc.name : demuxer hevc+aac flv video file 1544 * @tc.desc : function test 1545 */ 1546HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7100, TestSize.Level3) 1547{ 1548 int tarckType = 0; 1549 OH_AVCodecBufferAttr attr; 1550 bool videoIsEnd = false; 1551 int videoFrame = 0; 1552 const char *file = "/data/test/media/hevc_aac_c.flv"; 1553 int fd = open(file, O_RDONLY); 1554 int64_t size = GetFileSize(file); 1555 cout << file << "----------------------" << fd << "---------" << size << endl; 1556 source = OH_AVSource_CreateWithFD(fd, 0, size); 1557 ASSERT_NE(source, nullptr); 1558 demuxer = OH_AVDemuxer_CreateWithSource(source); 1559 ASSERT_NE(demuxer, nullptr); 1560 sourceFormat = OH_AVSource_GetSourceFormat(source); 1561 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1562 ASSERT_EQ(2, g_trackCount); 1563 for (int32_t index = 0; index < g_trackCount; index++) { 1564 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 1565 } 1566 int vKeyCount = 0; 1567 int aKeyCount = 0; 1568 int audioFrame = 0; 1569 bool audioIsEnd = false; 1570 while (!audioIsEnd || !videoIsEnd) { 1571 for (int32_t index = 0; index < g_trackCount; index++) { 1572 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1573 ASSERT_NE(trackFormat, nullptr); 1574 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1575 OH_AVFormat_Destroy(trackFormat); 1576 trackFormat = nullptr; 1577 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1578 continue; 1579 } 1580 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1581 if (tarckType == MEDIA_TYPE_VID) { 1582 SetVideoValue(attr, videoIsEnd, videoFrame, vKeyCount); 1583 } else if (tarckType == MEDIA_TYPE_AUD) { 1584 SetAudioValue(attr, audioIsEnd, audioFrame, aKeyCount); 1585 } 1586 } 1587 } 1588 ASSERT_EQ(audioFrame, 11208); 1589 ASSERT_EQ(aKeyCount, 11208); 1590 ASSERT_EQ(videoFrame, 6506); 1591 ASSERT_EQ(vKeyCount, 39); 1592 close(fd); 1593} 1594 1595/** 1596 * @tc.number : DEMUXER_RELI_7200 1597 * @tc.name : create source with uri,flv 1598 * @tc.desc : function test 1599 */ 1600HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7200, TestSize.Level0) 1601{ 1602 OH_AVCodecBufferAttr attr; 1603 const char *uri = "http://192.168.3.11:8080/share/avc_mp3.flv"; 1604 cout << uri << "------" << endl; 1605 int tarckType = 0; 1606 bool audioIsEnd = false; 1607 bool videoIsEnd = false; 1608 int audioFrame = 0; 1609 int videoFrame = 0; 1610 CreateDemuxer(const_cast<char *>(uri)); 1611 while (!audioIsEnd || !videoIsEnd) { 1612 for (int32_t index = 0; index < g_trackCount; index++) { 1613 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1614 ASSERT_NE(trackFormat, nullptr); 1615 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1616 OH_AVFormat_Destroy(trackFormat); 1617 trackFormat = nullptr; 1618 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1619 continue; 1620 } 1621 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1622 if (tarckType == MEDIA_TYPE_AUD) { 1623 SetAudioValue(attr, audioIsEnd, audioFrame); 1624 } else if (tarckType == MEDIA_TYPE_VID) { 1625 SetVideoValue(attr, videoIsEnd, videoFrame); 1626 } 1627 } 1628 } 1629 ASSERT_EQ(audioFrame, 385); 1630 ASSERT_EQ(videoFrame, 602); 1631} 1632 1633/** 1634 * @tc.number : DEMUXER_RELI_7300 1635 * @tc.name : create 16 instances create-destory 1636 * @tc.desc : function test 1637 */ 1638HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7300, TestSize.Level3) 1639{ 1640 int num = 0; 1641 while (num < 10) { 1642 num++; 1643 vector<std::thread> vecThread; 1644 const char *uri = "http://192.168.3.11:8080/share/avc_mp3.flv"; 1645 for (int i = 0; i < g_maxThread; i++) { 1646 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1647 cout << i << " uri: " << uri << endl; 1648 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1649 ASSERT_NE(source_list[i], nullptr); 1650 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1651 ASSERT_NE(demuxer_list[i], nullptr); 1652 vecThread.emplace_back(DemuxFunc, i, num); 1653 } 1654 for (auto &val : vecThread) { 1655 val.join(); 1656 } 1657 for (int i = 0; i < g_maxThread; i++) { 1658 if (demuxer_list[i] != nullptr) { 1659 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1660 demuxer_list[i] = nullptr; 1661 } 1662 1663 if (source_list[i] != nullptr) { 1664 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1665 source_list[i] = nullptr; 1666 } 1667 if (memory_list[i] != nullptr) { 1668 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1669 memory_list[i] = nullptr; 1670 } 1671 std::cout << i << " finish Destroy!!!!" << std::endl; 1672 } 1673 cout << "num: " << num << endl; 1674 } 1675} 1676 1677/** 1678 * @tc.number : DEMUXER_RELI_7400 1679 * @tc.name : create 16 instances repeat create-destory 1680 * @tc.desc : function test 1681 */ 1682HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7400, TestSize.Level3) 1683{ 1684 int num = 0; 1685 int len = 256; 1686 while (num < 10) { 1687 num++; 1688 vector<std::thread> vecThread; 1689 for (int i = 0; i < g_maxThread; i++) { 1690 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1691 char file[256] = {}; 1692 sprintf_s(file, len, "/data/test/media/16/%d_avc_mp3.flv", i); 1693 g_fdList[i] = open(file, O_RDONLY); 1694 int64_t size = GetFileSize(file); 1695 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 1696 1697 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 1698 ASSERT_NE(source_list[i], nullptr); 1699 1700 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1701 ASSERT_NE(demuxer_list[i], nullptr); 1702 vecThread.emplace_back(DemuxFunc, i, num); 1703 } 1704 for (auto &val : vecThread) { 1705 val.join(); 1706 } 1707 1708 for (int i = 0; i < g_maxThread; i++) { 1709 if (demuxer_list[i] != nullptr) { 1710 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1711 demuxer_list[i] = nullptr; 1712 } 1713 1714 if (source_list[i] != nullptr) { 1715 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1716 source_list[i] = nullptr; 1717 } 1718 if (memory_list[i] != nullptr) { 1719 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1720 memory_list[i] = nullptr; 1721 } 1722 std::cout << i << " finish Destroy!!!!" << std::endl; 1723 1724 close(g_fdList[i]); 1725 } 1726 cout << "num: " << num << endl; 1727 } 1728} 1729 1730/** 1731 * @tc.number : DEMUXER_RELI_7500 1732 * @tc.name : create source with uri,ape 1733 * @tc.desc : function test 1734 */ 1735HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7500, TestSize.Level0) 1736{ 1737 OH_AVCodecBufferAttr attr; 1738 bool isEnd = false; 1739 const char *uri = "http://192.168.3.11:8080/share/ape.ape"; 1740 cout << uri << "------" << endl; 1741 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1742 ASSERT_NE(source, nullptr); 1743 demuxer = OH_AVDemuxer_CreateWithSource(source); 1744 ASSERT_NE(demuxer, nullptr); 1745 sourceFormat = OH_AVSource_GetSourceFormat(source); 1746 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1747 for (int32_t index = 0; index < g_trackCount; index++) { 1748 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 1749 } 1750 int audioFrame = 0; 1751 int keyCount = 0; 1752 while (!isEnd) { 1753 for (int32_t index = 0; index < g_trackCount; index++) { 1754 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1755 cout << attr.size << "size---------------pts:" << attr.pts << endl; 1756 if (attr.flags == OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1757 isEnd = true; 1758 cout << "isend !!!!!!!!!!!!!!!" << endl; 1759 continue; 1760 } 1761 audioFrame++; 1762 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 1763 keyCount++; 1764 } 1765 } 1766 } 1767 ASSERT_EQ(audioFrame, 8); 1768 ASSERT_EQ(keyCount, 8); 1769} 1770 1771/** 1772 * @tc.number : DEMUXER_RELI_7600 1773 * @tc.name : demuxer h264+mp3 fmp4 network 1774 * @tc.desc : function test 1775 */ 1776HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7600, TestSize.Level2) 1777{ 1778 OH_AVCodecBufferAttr attr; 1779 const char *uri = "http://192.168.3.11:8080/share/h264_mp3_3mevx_fmp4.mp4"; 1780 cout << uri << "------" << endl; 1781 int tarckType = 0; 1782 bool audioIsEnd = false; 1783 bool videoIsEnd = false; 1784 int audioFrame = 0; 1785 int videoFrame = 0; 1786 CreateDemuxer(const_cast<char *>(uri)); 1787 while (!audioIsEnd || !videoIsEnd) { 1788 for (int32_t index = 0; index < g_trackCount; index++) { 1789 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1790 ASSERT_NE(trackFormat, nullptr); 1791 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1792 OH_AVFormat_Destroy(trackFormat); 1793 trackFormat = nullptr; 1794 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1795 continue; 1796 } 1797 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1798 if (tarckType == MEDIA_TYPE_AUD) { 1799 SetAudioValue(attr, audioIsEnd, audioFrame); 1800 } else if (tarckType == MEDIA_TYPE_VID) { 1801 SetVideoValue(attr, videoIsEnd, videoFrame); 1802 } 1803 } 1804 } 1805 ASSERT_EQ(audioFrame, 465); 1806 ASSERT_EQ(videoFrame, 369); 1807} 1808 1809/** 1810 * @tc.number : DEMUXER_RELI_7700 1811 * @tc.name : demuxer h265+aac fmp4 network 1812 * @tc.desc : function test 1813 */ 1814HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7700, TestSize.Level2) 1815{ 1816 OH_AVCodecBufferAttr attr; 1817 const char *uri = "http://192.168.3.11:8080/share/h265_aac_1mvex_fmp4.mp4"; 1818 cout << uri << "------" << endl; 1819 int tarckType = 0; 1820 bool audioIsEnd = false; 1821 bool videoIsEnd = false; 1822 int audioFrame = 0; 1823 int videoFrame = 0; 1824 CreateDemuxer(const_cast<char *>(uri)); 1825 while (!audioIsEnd || !videoIsEnd) { 1826 for (int32_t index = 0; index < g_trackCount; index++) { 1827 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1828 ASSERT_NE(trackFormat, nullptr); 1829 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1830 OH_AVFormat_Destroy(trackFormat); 1831 trackFormat = nullptr; 1832 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1833 continue; 1834 } 1835 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1836 if (tarckType == MEDIA_TYPE_AUD) { 1837 SetAudioValue(attr, audioIsEnd, audioFrame); 1838 } else if (tarckType == MEDIA_TYPE_VID) { 1839 SetVideoValue(attr, videoIsEnd, videoFrame); 1840 } 1841 } 1842 } 1843 ASSERT_EQ(audioFrame, 173); 1844 ASSERT_EQ(videoFrame, 242); 1845} 1846 1847/** 1848 * @tc.number : DEMUXER_RELI_7800 1849 * @tc.name : create 16 instances repeat create-destory h265+aac fmp4 file 1850 * @tc.desc : function test 1851 */ 1852HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7800, TestSize.Level3) 1853{ 1854 int num = 0; 1855 int len = 256; 1856 while (num < 1000) { 1857 num++; 1858 vector<std::thread> vecThread; 1859 for (int i = 0; i < g_maxThread; i++) { 1860 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1861 char file[256] = {}; 1862 sprintf_s(file, len, "/data/test/media/16/%d_h265_aac_1mvex_fmp4.mp4", i); 1863 g_fdList[i] = open(file, O_RDONLY); 1864 int64_t size = GetFileSize(file); 1865 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 1866 1867 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 1868 ASSERT_NE(source_list[i], nullptr); 1869 1870 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1871 ASSERT_NE(demuxer_list[i], nullptr); 1872 vecThread.emplace_back(DemuxFunc, i, num); 1873 } 1874 for (auto &val : vecThread) { 1875 val.join(); 1876 } 1877 1878 for (int i = 0; i < g_maxThread; i++) { 1879 if (demuxer_list[i] != nullptr) { 1880 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1881 demuxer_list[i] = nullptr; 1882 } 1883 1884 if (source_list[i] != nullptr) { 1885 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1886 source_list[i] = nullptr; 1887 } 1888 if (memory_list[i] != nullptr) { 1889 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1890 memory_list[i] = nullptr; 1891 } 1892 std::cout << i << " finish Destroy!!!!" << std::endl; 1893 1894 close(g_fdList[i]); 1895 } 1896 cout << "num: " << num << endl; 1897 } 1898} 1899 1900/** 1901 * @tc.number : DEMUXER_RELI_7900 1902 * @tc.name : create 16 instances create-destory h264+mp3 fmp4 network 1903 * @tc.desc : function test 1904 */ 1905HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_7900, TestSize.Level3) 1906{ 1907 int num = 0; 1908 while (num < 1000) { 1909 num++; 1910 vector<std::thread> vecThread; 1911 const char *uri = "http://192.168.3.11:8080/share/h264_mp3_3mevx_fmp4.mp4"; 1912 for (int i = 0; i < g_maxThread; i++) { 1913 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 1914 cout << i << " uri: " << uri << endl; 1915 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1916 ASSERT_NE(source_list[i], nullptr); 1917 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 1918 ASSERT_NE(demuxer_list[i], nullptr); 1919 vecThread.emplace_back(DemuxFunc, i, num); 1920 } 1921 for (auto &val : vecThread) { 1922 val.join(); 1923 } 1924 for (int i = 0; i < g_maxThread; i++) { 1925 if (demuxer_list[i] != nullptr) { 1926 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 1927 demuxer_list[i] = nullptr; 1928 } 1929 1930 if (source_list[i] != nullptr) { 1931 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 1932 source_list[i] = nullptr; 1933 } 1934 if (memory_list[i] != nullptr) { 1935 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 1936 memory_list[i] = nullptr; 1937 } 1938 std::cout << i << " finish Destroy!!!!" << std::endl; 1939 } 1940 cout << "num: " << num << endl; 1941 } 1942} 1943 1944/** 1945 * @tc.number : DEMUXER_RELI_8000 1946 * @tc.name : demuxer h264+aac ts hls network 1947 * @tc.desc : function test 1948 */ 1949HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8000, TestSize.Level0) 1950{ 1951 OH_AVCodecBufferAttr attr; 1952 const char *uri = "http://192.168.3.11:8080/share/h264_aac.m3u8"; 1953 cout << uri << "------" << endl; 1954 int tarckType = 0; 1955 bool audioIsEnd = false; 1956 bool videoIsEnd = false; 1957 int audioFrame = 0; 1958 int videoFrame = 0; 1959 CreateDemuxer(const_cast<char *>(uri)); 1960 while (!audioIsEnd || !videoIsEnd) { 1961 for (int32_t index = 0; index < g_trackCount; index++) { 1962 trackFormat = OH_AVSource_GetTrackFormat(source, index); 1963 ASSERT_NE(trackFormat, nullptr); 1964 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1965 OH_AVFormat_Destroy(trackFormat); 1966 trackFormat = nullptr; 1967 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 1968 continue; 1969 } 1970 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 1971 if (tarckType == MEDIA_TYPE_AUD) { 1972 SetAudioValue(attr, audioIsEnd, audioFrame); 1973 } else if (tarckType == MEDIA_TYPE_VID) { 1974 SetVideoValue(attr, videoIsEnd, videoFrame); 1975 } 1976 } 1977 } 1978 ASSERT_EQ(audioFrame, 528); 1979 ASSERT_EQ(videoFrame, 369); 1980} 1981 1982/** 1983 * @tc.number : DEMUXER_RELI_8100 1984 * @tc.name : demuxer h265+mp3 ts hls network 1985 * @tc.desc : function test 1986 */ 1987HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8100, TestSize.Level0) 1988{ 1989 OH_AVCodecBufferAttr attr; 1990 const char *uri = "http://192.168.3.11:8080/share/h265_mp3.m3u8"; 1991 cout << uri << "------" << endl; 1992 int tarckType = 0; 1993 bool audioIsEnd = false; 1994 bool videoIsEnd = false; 1995 int audioFrame = 0; 1996 int videoFrame = 0; 1997 CreateDemuxer(const_cast<char *>(uri)); 1998 while (!audioIsEnd || !videoIsEnd) { 1999 for (int32_t index = 0; index < g_trackCount; index++) { 2000 trackFormat = OH_AVSource_GetTrackFormat(source, index); 2001 ASSERT_NE(trackFormat, nullptr); 2002 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 2003 OH_AVFormat_Destroy(trackFormat); 2004 trackFormat = nullptr; 2005 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 2006 continue; 2007 } 2008 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 2009 if (tarckType == MEDIA_TYPE_AUD) { 2010 SetAudioValue(attr, audioIsEnd, audioFrame); 2011 } else if (tarckType == MEDIA_TYPE_VID) { 2012 SetVideoValue(attr, videoIsEnd, videoFrame); 2013 } 2014 } 2015 } 2016 ASSERT_EQ(audioFrame, 465); 2017 ASSERT_EQ(videoFrame, 726); 2018} 2019 2020/** 2021 * @tc.number : DEMUXER_RELI_8200 2022 * @tc.name : demuxer first level index hls network 2023 * @tc.desc : function test 2024 */ 2025HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8200, TestSize.Level2) 2026{ 2027 OH_AVCodecBufferAttr attr; 2028 const char *uri = "http://192.168.3.11:8080/share/first_level.m3u8"; 2029 cout << uri << "------" << endl; 2030 int tarckType = 0; 2031 bool audioIsEnd = false; 2032 bool videoIsEnd = false; 2033 int audioFrame = 0; 2034 int videoFrame = 0; 2035 CreateDemuxer(const_cast<char *>(uri)); 2036 while (!audioIsEnd || !videoIsEnd) { 2037 for (int32_t index = 0; index < g_trackCount; index++) { 2038 trackFormat = OH_AVSource_GetTrackFormat(source, index); 2039 ASSERT_NE(trackFormat, nullptr); 2040 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 2041 OH_AVFormat_Destroy(trackFormat); 2042 trackFormat = nullptr; 2043 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 2044 continue; 2045 } 2046 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 2047 if (tarckType == MEDIA_TYPE_AUD) { 2048 SetAudioValue(attr, audioIsEnd, audioFrame); 2049 } else if (tarckType == MEDIA_TYPE_VID) { 2050 SetVideoValue(attr, videoIsEnd, videoFrame); 2051 } 2052 } 2053 } 2054 cout << audioFrame << "audioFrame" << endl; 2055 cout << videoFrame << "videoFrame" << endl; 2056} 2057 2058/** 2059 * @tc.number : DEMUXER_RELI_8300 2060 * @tc.name : demuxer fixed path slicing hls network 2061 * @tc.desc : function test 2062 */ 2063HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8300, TestSize.Level2) 2064{ 2065 OH_AVCodecBufferAttr attr; 2066 const char *uri = "http://192.168.3.11:8080/share/fixed_path.m3u8"; 2067 cout << uri << "------" << endl; 2068 int tarckType = 0; 2069 bool audioIsEnd = false; 2070 bool videoIsEnd = false; 2071 int audioFrame = 0; 2072 int videoFrame = 0; 2073 CreateDemuxer(const_cast<char *>(uri)); 2074 while (!audioIsEnd || !videoIsEnd) { 2075 for (int32_t index = 0; index < g_trackCount; index++) { 2076 trackFormat = OH_AVSource_GetTrackFormat(source, index); 2077 ASSERT_NE(trackFormat, nullptr); 2078 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 2079 OH_AVFormat_Destroy(trackFormat); 2080 trackFormat = nullptr; 2081 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 2082 continue; 2083 } 2084 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 2085 if (tarckType == MEDIA_TYPE_AUD) { 2086 SetAudioValue(attr, audioIsEnd, audioFrame); 2087 } else if (tarckType == MEDIA_TYPE_VID) { 2088 SetVideoValue(attr, videoIsEnd, videoFrame); 2089 } 2090 } 2091 } 2092 ASSERT_EQ(audioFrame, 465); 2093 ASSERT_EQ(videoFrame, 726); 2094} 2095 2096/** 2097 * @tc.number : DEMUXER_RELI_8400 2098 * @tc.name : demuxer different sharded videos hls network 2099 * @tc.desc : function test 2100 */ 2101HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8400, TestSize.Level2) 2102{ 2103 OH_AVCodecBufferAttr attr; 2104 const char *uri = "http://192.168.3.11:8080/share/differemt_videos.m3u8"; 2105 cout << uri << "------" << endl; 2106 int tarckType = 0; 2107 bool audioIsEnd = false; 2108 bool videoIsEnd = false; 2109 int audioFrame = 0; 2110 int videoFrame = 0; 2111 CreateDemuxer(const_cast<char *>(uri)); 2112 while (!audioIsEnd || !videoIsEnd) { 2113 for (int32_t index = 0; index < g_trackCount; index++) { 2114 trackFormat = OH_AVSource_GetTrackFormat(source, index); 2115 ASSERT_NE(trackFormat, nullptr); 2116 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 2117 OH_AVFormat_Destroy(trackFormat); 2118 trackFormat = nullptr; 2119 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 2120 continue; 2121 } 2122 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 2123 if (tarckType == MEDIA_TYPE_AUD) { 2124 SetAudioValue(attr, audioIsEnd, audioFrame); 2125 } else if (tarckType == MEDIA_TYPE_VID) { 2126 SetVideoValue(attr, videoIsEnd, videoFrame); 2127 } 2128 } 2129 } 2130} 2131 2132/** 2133 * @tc.number : DEMUXER_RELI_8500 2134 * @tc.name : demuxer duration greater than TARGETDURATION hls network 2135 * @tc.desc : function test 2136 */ 2137HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8500, TestSize.Level2) 2138{ 2139 OH_AVCodecBufferAttr attr; 2140 const char *uri = "http://192.168.3.11:8080/share/duration_error.m3u8"; 2141 cout << uri << "------" << endl; 2142 int tarckType = 0; 2143 bool audioIsEnd = false; 2144 bool videoIsEnd = false; 2145 int audioFrame = 0; 2146 int videoFrame = 0; 2147 CreateDemuxer(const_cast<char *>(uri)); 2148 while (!audioIsEnd || !videoIsEnd) { 2149 for (int32_t index = 0; index < g_trackCount; index++) { 2150 trackFormat = OH_AVSource_GetTrackFormat(source, index); 2151 ASSERT_NE(trackFormat, nullptr); 2152 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 2153 OH_AVFormat_Destroy(trackFormat); 2154 trackFormat = nullptr; 2155 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) { 2156 continue; 2157 } 2158 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr)); 2159 if (tarckType == MEDIA_TYPE_AUD) { 2160 SetAudioValue(attr, audioIsEnd, audioFrame); 2161 } else if (tarckType == MEDIA_TYPE_VID) { 2162 SetVideoValue(attr, videoIsEnd, videoFrame); 2163 } 2164 } 2165 } 2166} 2167 2168/** 2169 * @tc.number : DEMUXER_RELI_8600 2170 * @tc.name : create 16 instances repeat create-destory h264+aac ts file 2171 * @tc.desc : function test 2172 */ 2173HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8600, TestSize.Level3) 2174{ 2175 int num = 0; 2176 int len = 256; 2177 while (num < 1000) { 2178 num++; 2179 vector<std::thread> vecThread; 2180 for (int i = 0; i < g_maxThread; i++) { 2181 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 2182 char file[256] = {}; 2183 sprintf_s(file, len, "/data/test/media/16/%d_h264_aac.m3u8", i); 2184 g_fdList[i] = open(file, O_RDONLY); 2185 int64_t size = GetFileSize(file); 2186 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 2187 2188 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 2189 ASSERT_NE(source_list[i], nullptr); 2190 2191 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 2192 ASSERT_NE(demuxer_list[i], nullptr); 2193 vecThread.emplace_back(DemuxFunc, i, num); 2194 } 2195 for (auto &val : vecThread) { 2196 val.join(); 2197 } 2198 2199 for (int i = 0; i < g_maxThread; i++) { 2200 if (demuxer_list[i] != nullptr) { 2201 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 2202 demuxer_list[i] = nullptr; 2203 } 2204 2205 if (source_list[i] != nullptr) { 2206 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 2207 source_list[i] = nullptr; 2208 } 2209 if (memory_list[i] != nullptr) { 2210 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 2211 memory_list[i] = nullptr; 2212 } 2213 std::cout << i << " finish Destroy!!!!" << std::endl; 2214 2215 close(g_fdList[i]); 2216 } 2217 cout << "num: " << num << endl; 2218 } 2219} 2220 2221/** 2222 * @tc.number : DEMUXER_RELI_8700 2223 * @tc.name : create 16 instances create-destory h265+mp3 ts network 2224 * @tc.desc : function test 2225 */ 2226HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8700, TestSize.Level3) 2227{ 2228 int num = 0; 2229 while (num < 1000) { 2230 num++; 2231 vector<std::thread> vecThread; 2232 const char *uri = "http://192.168.3.11:8080/share/h265_mp3.m3u8"; 2233 for (int i = 0; i < g_maxThread; i++) { 2234 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 2235 cout << i << " uri: " << uri << endl; 2236 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 2237 ASSERT_NE(source_list[i], nullptr); 2238 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 2239 ASSERT_NE(demuxer_list[i], nullptr); 2240 vecThread.emplace_back(DemuxFunc, i, num); 2241 } 2242 for (auto &val : vecThread) { 2243 val.join(); 2244 } 2245 for (int i = 0; i < g_maxThread; i++) { 2246 if (demuxer_list[i] != nullptr) { 2247 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 2248 demuxer_list[i] = nullptr; 2249 } 2250 2251 if (source_list[i] != nullptr) { 2252 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 2253 source_list[i] = nullptr; 2254 } 2255 if (memory_list[i] != nullptr) { 2256 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 2257 memory_list[i] = nullptr; 2258 } 2259 std::cout << i << " finish Destroy!!!!" << std::endl; 2260 } 2261 cout << "num: " << num << endl; 2262 } 2263} 2264 2265/** 2266 * @tc.number : DEMUXER_RELI_8800 2267 * @tc.name : create srt demuxer with uri and read 2268 * @tc.desc : function test 2269 */ 2270HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8800, TestSize.Level2) 2271{ 2272 OH_AVCodecBufferAttr attr; 2273 int srtIndex = 1; 2274 int srtSubtitle = 0; 2275 const char *uri = "http://192.168.3.11:8080/share/srt_test.srt"; 2276 cout << uri << "------" << endl; 2277 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 2278 ASSERT_NE(source, nullptr); 2279 demuxer = OH_AVDemuxer_CreateWithSource(source); 2280 ASSERT_NE(demuxer, nullptr); 2281 sourceFormat = OH_AVSource_GetSourceFormat(source); 2282 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 2283 ASSERT_EQ(1, g_trackCount); 2284 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 2285 while (true) { 2286 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 2287 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 2288 cout << " srt is end !!!!!!!!!!!!!!!" << endl; 2289 break; 2290 } 2291 uint8_t *data = OH_AVMemory_GetAddr(memory); 2292 srtSubtitle = atoi(reinterpret_cast<const char*>(data)); 2293 cout << "subtitle" << "----------------" << srtSubtitle << "-----------------" << endl; 2294 ASSERT_EQ(srtSubtitle, srtIndex); 2295 srtIndex++; 2296 } 2297} 2298 2299/** 2300 * @tc.number : DEMUXER_RELI_8900 2301 * @tc.name : create srt demuxer with uri and seek+read 2302 * @tc.desc : function test 2303 */ 2304HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_8900, TestSize.Level2) 2305{ 2306 OH_AVCodecBufferAttr attr; 2307 int srtIndex = 1; 2308 int srtSubtitle = 0; 2309 uint8_t *data; 2310 const char *uri = "http://192.168.3.11:8080/share/srt_test.srt"; 2311 cout << uri << "------" << endl; 2312 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 2313 ASSERT_NE(source, nullptr); 2314 demuxer = OH_AVDemuxer_CreateWithSource(source); 2315 ASSERT_NE(demuxer, nullptr); 2316 sourceFormat = OH_AVSource_GetSourceFormat(source); 2317 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 2318 ASSERT_EQ(1, g_trackCount); 2319 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 2320 2321 for (int index = 0; index < 5; index++) { 2322 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 2323 data = OH_AVMemory_GetAddr(memory); 2324 srtSubtitle = atoi(reinterpret_cast<const char*>(data)); 2325 cout << "subtitle"<< "----------------" << srtSubtitle << "-----------------" << endl; 2326 ASSERT_EQ(srtSubtitle, srtIndex); 2327 srtIndex++; 2328 } 2329 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, 5400, SEEK_MODE_CLOSEST_SYNC)); 2330 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 2331 data = OH_AVMemory_GetAddr(memory); 2332 srtSubtitle = atoi(reinterpret_cast<const char*>(data)); 2333 cout << "subtitle"<< "----------------" << srtSubtitle << "-----------------" << endl; 2334 srtIndex = 2; 2335 ASSERT_EQ(srtSubtitle, srtIndex); 2336 2337 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, 21400, SEEK_MODE_CLOSEST_SYNC)); 2338 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 2339 data = OH_AVMemory_GetAddr(memory); 2340 srtSubtitle = atoi(reinterpret_cast<const char*>(data)); 2341 cout << "subtitle"<< "----------------" << srtSubtitle << "-----------------" << endl; 2342 srtIndex = 7; 2343 ASSERT_EQ(srtSubtitle, srtIndex); 2344 2345 while (true) { 2346 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 2347 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 2348 cout << " srt is end !!!!!!!!!!!!!!!" << endl; 2349 break; 2350 } 2351 data = OH_AVMemory_GetAddr(memory); 2352 srtSubtitle = atoi(reinterpret_cast<const char*>(data)); 2353 cout << "subtitle"<< "----------------" << srtSubtitle << "-----------------" << endl; 2354 srtIndex++; 2355 ASSERT_EQ(srtSubtitle, srtIndex); 2356 } 2357} 2358 2359/** 2360 * @tc.number : DEMUXER_RELI_9000 2361 * @tc.name : create 16 instances repeat create-destory with srt file 2362 * @tc.desc : function test 2363 */ 2364HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_9000, TestSize.Level3) 2365{ 2366 int num = 0; 2367 int len = 256; 2368 while (num < 10) { 2369 num++; 2370 vector<std::thread> vecThread; 2371 for (int i = 0; i < g_maxThread; i++) { 2372 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 2373 char file[256] = {}; 2374 sprintf_s(file, len, "/data/test/media/16/%d_srt_test.srt", i); 2375 g_fdList[i] = open(file, O_RDONLY); 2376 int64_t size = GetFileSize(file); 2377 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 2378 2379 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 2380 ASSERT_NE(source_list[i], nullptr); 2381 2382 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 2383 ASSERT_NE(demuxer_list[i], nullptr); 2384 vecThread.emplace_back(DemuxSrtFunc, i, num); 2385 } 2386 for (auto &val : vecThread) { 2387 val.join(); 2388 } 2389 2390 for (int i = 0; i < g_maxThread; i++) { 2391 if (demuxer_list[i] != nullptr) { 2392 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 2393 demuxer_list[i] = nullptr; 2394 } 2395 2396 if (source_list[i] != nullptr) { 2397 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 2398 source_list[i] = nullptr; 2399 } 2400 if (memory_list[i] != nullptr) { 2401 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 2402 memory_list[i] = nullptr; 2403 } 2404 std::cout << i << " finish Destroy!!!!" << std::endl; 2405 2406 close(g_fdList[i]); 2407 } 2408 cout << "num: " << num << endl; 2409 } 2410} 2411 2412/** 2413 * @tc.number : DEMUXER_RELI_9100 2414 * @tc.name : create 16 instances repeat create-destory with srt uri 2415 * @tc.desc : function test 2416 */ 2417HWTEST_F(DemuxerReliNdkTest, DEMUXER_RELI_9100, TestSize.Level3) 2418{ 2419 int num = 0; 2420 while (num < 10) { 2421 num++; 2422 vector<std::thread> vecThread; 2423 const char *uri = "http://192.168.3.11:8080/share/srt_test.srt"; 2424 for (int i = 0; i < g_maxThread; i++) { 2425 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 2426 cout << i << " uri: " << uri << endl; 2427 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 2428 ASSERT_NE(source_list[i], nullptr); 2429 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 2430 ASSERT_NE(demuxer_list[i], nullptr); 2431 vecThread.emplace_back(DemuxSrtFunc, i, num); 2432 } 2433 for (auto &val : vecThread) { 2434 val.join(); 2435 } 2436 for (int i = 0; i < g_maxThread; i++) { 2437 if (demuxer_list[i] != nullptr) { 2438 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 2439 demuxer_list[i] = nullptr; 2440 } 2441 2442 if (source_list[i] != nullptr) { 2443 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 2444 source_list[i] = nullptr; 2445 } 2446 if (memory_list[i] != nullptr) { 2447 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 2448 memory_list[i] = nullptr; 2449 } 2450 std::cout << i << " finish Destroy!!!!" << std::endl; 2451 } 2452 cout << "num: " << num << endl; 2453 } 2454} 2455 2456}