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 "gtest/gtest.h" 17 18#include "avdemuxer.h" 19#include "avsource.h" 20#include "meta/format.h" 21#include "avcodec_errors.h" 22#include "avcodec_common.h" 23#include "buffer/avsharedmemory.h" 24#include "buffer/avsharedmemorybase.h" 25#include "securec.h" 26#include "inner_demuxer_sample.h" 27 28#include <iostream> 29#include <cstdio> 30#include <string> 31#include <fcntl.h> 32 33#include "native_avcodec_base.h" 34#include "native_avdemuxer.h" 35#include "native_avformat.h" 36#include "native_avsource.h" 37#include <thread> 38#include "native_avmemory.h" 39 40using namespace std; 41using namespace OHOS; 42using namespace OHOS::MediaAVCodec; 43using namespace OHOS::Media; 44using namespace testing::ext; 45 46namespace { 47class DemuxerNetNdkTest : public testing::Test { 48public: 49 // SetUpTestCase: Called before all test cases 50 static void SetUpTestCase(void); 51 // TearDownTestCase: Called after all test case 52 static void TearDownTestCase(void); 53 // SetUp: Called before each test cases 54 void SetUp(void); 55 // TearDown: Called after each test cases 56 void TearDown(void); 57 58public: 59 int32_t fd_ = -1; 60 int64_t size; 61}; 62static OH_AVMemory *memory = nullptr; 63static OH_AVFormat *sourceFormat = nullptr; 64static OH_AVFormat *trackFormat = nullptr; 65static OH_AVSource *source = nullptr; 66static OH_AVDemuxer *demuxer = nullptr; 67static int32_t g_trackCount = 0; 68static OH_AVBuffer *avBuffer = nullptr; 69 70static OH_AVSource *sourceV = nullptr; 71static OH_AVDemuxer *demuxerV = nullptr; 72static OH_AVFormat *sourceFormatV = nullptr; 73static OH_AVFormat *trackFormatV = nullptr; 74static OH_AVMemory *memoryV = nullptr; 75std::map<int64_t, int32_t> myMap; 76static int32_t g_maxThread = 16; 77OH_AVSource *source_list[16] = {}; 78OH_AVMemory *memory_list[16] = {}; 79OH_AVDemuxer *demuxer_list[16] = {}; 80int g_fdList[16] = {}; 81OH_AVBuffer *avBuffer_list[16] = {}; 82static int32_t g_width = 3840; 83static int32_t g_height = 2160; 84constexpr int32_t LAYOUTMONO = 4; 85constexpr int32_t LAYOUTDUAL = 3; 86constexpr int32_t SAMPLERATEMONO = 8000; 87constexpr int32_t SAMPLERATEDUAL = 44100; 88constexpr int32_t COUNTMONO = 1; 89constexpr int32_t COUNTDUAL = 2; 90constexpr int32_t BITRATEMONO = 64000; 91constexpr int32_t BITRATEDUAL = 705600; 92constexpr int32_t VTTSEEKFORWARD = 5100; 93constexpr int32_t VTTSEEKBACK = 2100; 94constexpr int64_t BITRATEDUALMP4 = 8594194000; 95constexpr int32_t BITRATEMONOMP4 = 135105000; 96constexpr int64_t BITRATEDUAL14 = 8222430000; 97constexpr int32_t BITRATEMONO14 = 156150000; 98constexpr int32_t ATTRPTS = 1000; 99void DemuxerNetNdkTest::SetUpTestCase() {} 100void DemuxerNetNdkTest::TearDownTestCase() {} 101void DemuxerNetNdkTest::SetUp() 102{ 103 memory = OH_AVMemory_Create(g_width * g_height); 104 memoryV = OH_AVMemory_Create(g_width * g_height); 105 g_trackCount = 0; 106} 107void DemuxMoreTearDown() 108{ 109 for (int i = 0; i < g_maxThread; i++) { 110 if (demuxer_list[i] != nullptr) { 111 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 112 demuxer_list[i] = nullptr; 113 } 114 if (source_list[i] != nullptr) { 115 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 116 source_list[i] = nullptr; 117 } 118 if (memory_list[i] != nullptr) { 119 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 120 memory_list[i] = nullptr; 121 } 122 if (avBuffer_list[i] != nullptr) { 123 ASSERT_EQ(AV_ERR_OK, OH_AVBuffer_Destroy(avBuffer_list[i])); 124 avBuffer_list[i] = nullptr; 125 } 126 std::cout << i << " finish Destroy!!!!" << std::endl; 127 close(g_fdList[i]); 128 } 129 if (trackFormatV != nullptr) { 130 OH_AVFormat_Destroy(trackFormatV); 131 trackFormatV = nullptr; 132 } 133 if (sourceFormatV != nullptr) { 134 OH_AVFormat_Destroy(sourceFormatV); 135 sourceFormatV = nullptr; 136 } 137 if (memoryV != nullptr) { 138 OH_AVMemory_Destroy(memoryV); 139 memoryV = nullptr; 140 } 141 if (sourceV != nullptr) { 142 OH_AVSource_Destroy(sourceV); 143 sourceV = nullptr; 144 } 145 if (demuxerV != nullptr) { 146 OH_AVDemuxer_Destroy(demuxerV); 147 demuxerV = nullptr; 148 } 149 if (!myMap.empty()) { 150 myMap.clear(); 151 } 152} 153void DemuxerNetNdkTest::TearDown() 154{ 155 if (fd_ > 0) { 156 close(fd_); 157 fd_ = -1; 158 } 159 if (demuxer != nullptr) { 160 OH_AVDemuxer_Destroy(demuxer); 161 demuxer = nullptr; 162 } 163 if (memory != nullptr) { 164 OH_AVMemory_Destroy(memory); 165 memory = nullptr; 166 } 167 if (source != nullptr) { 168 OH_AVSource_Destroy(source); 169 source = nullptr; 170 } 171 if (avBuffer != nullptr) { 172 OH_AVBuffer_Destroy(avBuffer); 173 avBuffer = nullptr; 174 } 175 if (trackFormat != nullptr) { 176 OH_AVFormat_Destroy(trackFormat); 177 trackFormat = nullptr; 178 } 179 if (sourceFormat != nullptr) { 180 OH_AVFormat_Destroy(sourceFormat); 181 sourceFormat = nullptr; 182 } 183 DemuxMoreTearDown(); 184} 185} // namespace 186 187namespace { 188 static int64_t GetFileSize(const char *fileName) 189 { 190 int64_t fileSize = 0; 191 if (fileName != nullptr) { 192 struct stat fileStatus {}; 193 if (stat(fileName, &fileStatus) == 0) { 194 fileSize = static_cast<int64_t>(fileStatus.st_size); 195 } 196 } 197 return fileSize; 198 } 199 void DemuxFuncWav(int i, int loop) 200 { 201 bool audioIsEnd = false; 202 OH_AVCodecBufferAttr bufferAttr; 203 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer_list[i], 0)); 204 int index = 0; 205 while (!audioIsEnd) { 206 if (audioIsEnd && (index == OH_MediaType::MEDIA_TYPE_AUD)) { 207 continue; 208 } 209 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSampleBuffer(demuxer_list[i], index, avBuffer_list[i])); 210 ASSERT_NE(avBuffer_list[i], nullptr); 211 ASSERT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(avBuffer_list[i], &bufferAttr)); 212 if ((index == OH_MediaType::MEDIA_TYPE_AUD) && 213 (bufferAttr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS)) { 214 audioIsEnd = true; 215 } 216 } 217 } 218 void DemuxFuncVtt(int i, int loop) 219 { 220 bool audioIsEnd = false; 221 OH_AVCodecBufferAttr attr; 222 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer_list[i], 0)); 223 int index = 2; 224 while (!audioIsEnd) { 225 if (audioIsEnd && (index == OH_MediaType::MEDIA_TYPE_SUBTITLE)) { 226 continue; 227 } 228 ASSERT_NE(demuxer_list[i], nullptr); 229 ASSERT_NE(memory_list[i], nullptr); 230 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer_list[i], 0, memory_list[i], &attr)); 231 ASSERT_NE(memory_list[i], nullptr); 232 if ((index == OH_MediaType::MEDIA_TYPE_SUBTITLE) && 233 (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS)) { 234 audioIsEnd = true; 235 } 236 } 237 } 238 static void CheckAudioParam(OH_AVSource *audioSource, int &audioFrameAll) 239 { 240 int akeyCount = 0; 241 int tarckType = 0; 242 OH_AVCodecBufferAttr bufferAttr; 243 bool audioIsEnd = false; 244 int32_t count = 0; 245 int32_t rate = 0; 246 int64_t bitrate = 0; 247 int64_t layout = 0; 248 int32_t index = 0; 249 const char* mimeType = nullptr; 250 while (!audioIsEnd) { 251 trackFormat = OH_AVSource_GetTrackFormat(audioSource, index); 252 ASSERT_NE(trackFormat, nullptr); 253 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 254 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSampleBuffer(demuxer, index, avBuffer)); 255 ASSERT_NE(avBuffer, nullptr); 256 ASSERT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(avBuffer, &bufferAttr)); 257 if (tarckType == OH_MediaType::MEDIA_TYPE_AUD) { 258 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 259 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, &rate)); 260 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, &count)); 261 ASSERT_TRUE(OH_AVFormat_GetLongValue(trackFormat, OH_MD_KEY_CHANNEL_LAYOUT, &layout)); 262 ASSERT_TRUE(OH_AVFormat_GetLongValue(trackFormat, OH_MD_KEY_BITRATE, &bitrate)); 263 if (bufferAttr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 264 audioIsEnd = true; 265 cout << audioFrameAll << " audio is end !!!!!!!!!!!!!!!" << endl; 266 continue; 267 } 268 audioFrameAll++; 269 if (bufferAttr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) { 270 akeyCount++; 271 } 272 } 273 } 274 if (count == 1) { 275 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_AUDIO_G711MU)); 276 ASSERT_EQ(layout, LAYOUTMONO); 277 ASSERT_EQ(rate, SAMPLERATEMONO); 278 ASSERT_EQ(count, COUNTMONO); 279 ASSERT_EQ(bitrate, BITRATEMONO); 280 } else { 281 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_AUDIO_G711MU)); 282 ASSERT_EQ(layout, LAYOUTDUAL); 283 ASSERT_EQ(rate, SAMPLERATEDUAL); 284 ASSERT_EQ(count, COUNTDUAL); 285 ASSERT_EQ(bitrate, BITRATEDUAL); 286 } 287 cout << akeyCount << "---akeyCount---" << endl; 288 } 289 290 static void MyMapVtt(const int64_t attrPts, const char *fileV) 291 { 292 OH_AVCodecBufferAttr attrV; 293 sourceV = OH_AVSource_CreateWithURI(const_cast<char *>(fileV)); 294 ASSERT_NE(sourceV, nullptr); 295 demuxerV = OH_AVDemuxer_CreateWithSource(sourceV); 296 ASSERT_NE(demuxerV, nullptr); 297 const char* mimeTypeV = nullptr; 298 sourceFormatV = OH_AVSource_GetSourceFormat(sourceV); 299 trackFormatV = OH_AVSource_GetTrackFormat(sourceV, 0); 300 ASSERT_NE(trackFormatV, nullptr); 301 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormatV, OH_MD_KEY_CODEC_MIME, &mimeTypeV)); 302 ASSERT_EQ(0, strcmp(mimeTypeV, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 303 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormatV, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 304 ASSERT_EQ(1, g_trackCount); 305 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxerV, 0)); 306 int tarckTypeV = 0; 307 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormatV, OH_MD_KEY_TRACK_TYPE, &tarckTypeV)); 308 ASSERT_EQ(tarckTypeV, OH_MediaType::MEDIA_TYPE_SUBTITLE); 309 if (attrPts > 0) { 310 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxerV, attrPts / ATTRPTS, 311 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 312 } 313 bool islast = true; 314 while (islast) { 315 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxerV, 0, memoryV, &attrV)); 316 if (attrV.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 317 islast = false; 318 } 319 myMap.insert(pair<int64_t, int32_t>(attrV.pts, attrV.size)); 320 } 321 } 322 /** 323 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0110 324 * @tc.name : demuxer timed metadata with 1 meta track and video track uri-meta track at 0 325 * @tc.desc : func test 326 */ 327 HWTEST_F(DemuxerNetNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0110, TestSize.Level1) 328 { 329 auto demuxerSample = make_unique<InnerDemuxerSample>(); 330 const char *uri = "http://192.168.3.11:8080/share/Timedmetadata1Track0.mp4"; 331 ASSERT_EQ(demuxerSample->InitWithFile(uri, false), AVCS_ERR_OK); 332 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1); 333 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(0, 1), 0); 334 ASSERT_EQ(demuxerSample->CheckTimedMeta(0), 0); 335 } 336 337 /** 338 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0120 339 * @tc.name : demuxer timed metadata with 1 meta track and video track uri-meta track at 1 340 * @tc.desc : func test 341 */ 342 HWTEST_F(DemuxerNetNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0120, TestSize.Level1) 343 { 344 auto demuxerSample = make_unique<InnerDemuxerSample>(); 345 const char *uri = "http://192.168.3.11:8080/share/Timedmetadata1Track1.mp4"; 346 ASSERT_EQ(demuxerSample->InitWithFile(uri, false), AVCS_ERR_OK); 347 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1); 348 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(1, 0), 0); 349 ASSERT_EQ(demuxerSample->CheckTimedMeta(1), 0); 350 } 351 352 /** 353 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0130 354 * @tc.name : demuxer timed metadata with 1 meta track and video track uri-meta track at 2 355 * @tc.desc : func test 356 */ 357 HWTEST_F(DemuxerNetNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0130, TestSize.Level1) 358 { 359 auto demuxerSample = make_unique<InnerDemuxerSample>(); 360 const char *uri = "http://192.168.3.11:8080/share/Timedmetadata1Track2.mp4"; 361 ASSERT_EQ(demuxerSample->InitWithFile(uri, false), AVCS_ERR_OK); 362 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1); 363 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(2, 0), 0); 364 ASSERT_EQ(demuxerSample->CheckTimedMeta(2), 0); 365 } 366 367 /** 368 * @tc.number : DEMUXER_TIMED_META_INNER_FUNC_0140 369 * @tc.name : demuxer timed metadata with 2 meta track and video track uri 370 * @tc.desc : func test 371 */ 372 HWTEST_F(DemuxerNetNdkTest, DEMUXER_TIMED_META_INNER_FUNC_0140, TestSize.Level1) 373 { 374 auto demuxerSample = make_unique<InnerDemuxerSample>(); 375 const char *uri = "http://192.168.3.11:8080/share/Timedmetadata2Track2.mp4"; 376 ASSERT_EQ(demuxerSample->InitWithFile(uri, false), AVCS_ERR_OK); 377 ASSERT_EQ(demuxerSample->CheckHasTimedMeta(), 1); 378 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(2, 0), 0); 379 ASSERT_EQ(demuxerSample->CheckTimedMetaFormat(3, 0), 0); 380 ASSERT_EQ(demuxerSample->CheckTimedMeta(3), 0); 381 } 382 /** 383 * @tc.number : DEMUXER_FUNC_NET_001 384 * @tc.name : create 16 instances repeat create-destory with wav file 385 * @tc.desc : function test 386 */ 387 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_NET_001, TestSize.Level2) 388 { 389 int num = 0; 390 int len = 256; 391 while (num < 10) { 392 num++; 393 vector<std::thread> vecThread; 394 for (int i = 0; i < g_maxThread; i++) { 395 char file[256] = {}; 396 sprintf_s(file, len, "/data/test/media/16/%d_wav_audio_test_202406290859.wav", i); 397 g_fdList[i] = open(file, O_RDONLY); 398 int64_t size = GetFileSize(file); 399 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 400 avBuffer_list[i] = OH_AVBuffer_Create(size); 401 ASSERT_NE(avBuffer_list[i], nullptr); 402 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 403 ASSERT_NE(source_list[i], nullptr); 404 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 405 ASSERT_NE(demuxer_list[i], nullptr); 406 vecThread.emplace_back(DemuxFuncWav, i, num); 407 } 408 for (auto &val : vecThread) { 409 val.join(); 410 } 411 for (int i = 0; i < g_maxThread; i++) { 412 if (demuxer_list[i] != nullptr) { 413 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 414 demuxer_list[i] = nullptr; 415 } 416 if (source_list[i] != nullptr) { 417 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 418 source_list[i] = nullptr; 419 } 420 if (avBuffer_list[i] != nullptr) { 421 ASSERT_EQ(AV_ERR_OK, OH_AVBuffer_Destroy(avBuffer_list[i])); 422 avBuffer_list[i] = nullptr; 423 } 424 std::cout << i << " finish Destroy!!!!" << std::endl; 425 close(g_fdList[i]); 426 } 427 cout << "num: " << num << endl; 428 } 429 } 430 431 /** 432 * @tc.number : DEMUXER_FUNC_NET_002 433 * @tc.name : create 16 instances repeat create-destory with wav network file 434 * @tc.desc : function test 435 */ 436 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_NET_002, TestSize.Level3) 437 { 438 int num = 0; 439 int sizeinfo = 421888; 440 while (num < 10) { 441 num++; 442 vector<std::thread> vecThread; 443 const char *uri = "http://192.168.3.11:8080/share/audio/audio/wav_audio_test_202406290859.wav"; 444 for (int i = 0; i < g_maxThread; i++) { 445 avBuffer_list[i] = OH_AVBuffer_Create(sizeinfo); 446 ASSERT_NE(avBuffer_list[i], nullptr); 447 cout << i << " uri: " << uri << endl; 448 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 449 ASSERT_NE(source_list[i], nullptr); 450 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 451 ASSERT_NE(demuxer_list[i], nullptr); 452 vecThread.emplace_back(DemuxFuncWav, i, num); 453 } 454 for (auto &val : vecThread) { 455 val.join(); 456 } 457 for (int i = 0; i < g_maxThread; i++) { 458 if (demuxer_list[i] != nullptr) { 459 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 460 demuxer_list[i] = nullptr; 461 } 462 if (source_list[i] != nullptr) { 463 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 464 source_list[i] = nullptr; 465 } 466 if (avBuffer_list[i] != nullptr) { 467 ASSERT_EQ(AV_ERR_OK, OH_AVBuffer_Destroy(avBuffer_list[i])); 468 avBuffer_list[i] = nullptr; 469 } 470 std::cout << i << " finish Destroy!!!!" << std::endl; 471 } 472 cout << "num: " << num << endl; 473 } 474 } 475 /** 476 * @tc.number : DEMUXER_FUNC_NET_003 477 * @tc.name : create pcm-mulaw wav demuxer with network file 478 * @tc.desc : function test 479 */ 480 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_NET_003, TestSize.Level2) 481 { 482 int audioFrame = 0; 483 int sizeinfo = 421888; 484 const char *uri = "http://192.168.3.11:8080/share/audio/audio/wav_audio_test_202406290859.wav"; 485 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 486 ASSERT_NE(source, nullptr); 487 demuxer = OH_AVDemuxer_CreateWithSource(source); 488 ASSERT_NE(demuxer, nullptr); 489 avBuffer = OH_AVBuffer_Create(sizeinfo); 490 ASSERT_NE(avBuffer, nullptr); 491 sourceFormat = OH_AVSource_GetSourceFormat(source); 492 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 493 ASSERT_EQ(1, g_trackCount); 494 for (int32_t index = 0; index < g_trackCount; index++) { 495 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 496 } 497 CheckAudioParam(source, audioFrame); 498 ASSERT_EQ(103, audioFrame); 499 } 500 /** 501 * @tc.number : DEMUXER_FUNC_NET_004 502 * @tc.name : create pcm-mulaw wav demuxer with Mono channel uri file 503 * @tc.desc : function test 504 */ 505 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_NET_004, TestSize.Level2) 506 { 507 int sizeinfo = 28672; 508 int audioFrame = 0; 509 const char *uri = "http://192.168.3.11:8080/share/audio/audio/7FBD5E21-503C-41A8-83B4-34548FC01562.wav"; 510 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 511 ASSERT_NE(source, nullptr); 512 demuxer = OH_AVDemuxer_CreateWithSource(source); 513 ASSERT_NE(demuxer, nullptr); 514 avBuffer = OH_AVBuffer_Create(sizeinfo); 515 ASSERT_NE(avBuffer, nullptr); 516 sourceFormat = OH_AVSource_GetSourceFormat(source); 517 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 518 ASSERT_EQ(1, g_trackCount); 519 for (int32_t index = 0; index < g_trackCount; index++) { 520 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index)); 521 } 522 CheckAudioParam(source, audioFrame); 523 ASSERT_EQ(7, audioFrame); 524 } 525 /** 526 * @tc.number : DEMUXER_FUNC_VTT_001 527 * @tc.name : create 16 instances repeat create-destory with vtt file 528 * @tc.desc : function test 529 */ 530 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_001, TestSize.Level3) 531 { 532 int num = 0; 533 int len = 256; 534 while (num < 10) { 535 num++; 536 vector<std::thread> vecThread; 537 for (int i = 0; i < g_maxThread; i++) { 538 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 539 char file[256] = {}; 540 sprintf_s(file, len, "/data/test/media/16/%d_webvtt_test.vtt", i); 541 g_fdList[i] = open(file, O_RDONLY); 542 int64_t size = GetFileSize(file); 543 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 544 545 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 546 ASSERT_NE(source_list[i], nullptr); 547 548 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 549 ASSERT_NE(demuxer_list[i], nullptr); 550 vecThread.emplace_back(DemuxFuncVtt, i, num); 551 } 552 for (auto &val : vecThread) { 553 val.join(); 554 } 555 556 for (int i = 0; i < g_maxThread; i++) { 557 if (demuxer_list[i] != nullptr) { 558 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 559 demuxer_list[i] = nullptr; 560 } 561 562 if (source_list[i] != nullptr) { 563 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 564 source_list[i] = nullptr; 565 } 566 if (memory_list[i] != nullptr) { 567 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 568 memory_list[i] = nullptr; 569 } 570 std::cout << i << " finish Destroy!!!!" << std::endl; 571 572 close(g_fdList[i]); 573 } 574 cout << "num: " << num << endl; 575 } 576 } 577 578 /** 579 * @tc.number : DEMUXER_FUNC_VTT_002 580 * @tc.name : create 16 instances repeat create-destory with vtt uri 581 * @tc.desc : function test 582 */ 583 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_002, TestSize.Level3) 584 { 585 int num = 0; 586 while (num < 10) { 587 num++; 588 vector<std::thread> vecThread; 589 const char *uri = "http://192.168.3.11:8080/share/audio/webvtt_test.vtt"; 590 for (int i = 0; i < g_maxThread; i++) { 591 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 592 cout << i << " uri: " << uri << endl; 593 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 594 ASSERT_NE(source_list[i], nullptr); 595 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 596 ASSERT_NE(demuxer_list[i], nullptr); 597 vecThread.emplace_back(DemuxFuncVtt, i, num); 598 } 599 for (auto &val : vecThread) { 600 val.join(); 601 } 602 for (int i = 0; i < g_maxThread; i++) { 603 if (demuxer_list[i] != nullptr) { 604 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 605 demuxer_list[i] = nullptr; 606 } 607 608 if (source_list[i] != nullptr) { 609 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 610 source_list[i] = nullptr; 611 } 612 if (memory_list[i] != nullptr) { 613 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 614 memory_list[i] = nullptr; 615 } 616 std::cout << i << " finish Destroy!!!!" << std::endl; 617 } 618 cout << "num: " << num << endl; 619 } 620 } 621 /** 622 * @tc.number : DEMUXER_FUNC_VTT_003 623 * @tc.name : create 16 instances repeat create-destory with vtt MP4 file 624 * @tc.desc : function test 625 */ 626 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_003, TestSize.Level3) 627 { 628 int num = 0; 629 int len = 256; 630 while (num < 10) { 631 num++; 632 vector<std::thread> vecThread; 633 for (int i = 0; i < g_maxThread; i++) { 634 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 635 char file[256] = {}; 636 sprintf_s(file, len, "/data/test/media/16/%d_subtitle_webvtt_en_GB_15.mp4", i); 637 g_fdList[i] = open(file, O_RDONLY); 638 int64_t size = GetFileSize(file); 639 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 640 641 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 642 ASSERT_NE(source_list[i], nullptr); 643 644 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 645 ASSERT_NE(demuxer_list[i], nullptr); 646 vecThread.emplace_back(DemuxFuncVtt, i, num); 647 } 648 for (auto &val : vecThread) { 649 val.join(); 650 } 651 652 for (int i = 0; i < g_maxThread; i++) { 653 if (demuxer_list[i] != nullptr) { 654 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 655 demuxer_list[i] = nullptr; 656 } 657 658 if (source_list[i] != nullptr) { 659 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 660 source_list[i] = nullptr; 661 } 662 if (memory_list[i] != nullptr) { 663 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 664 memory_list[i] = nullptr; 665 } 666 std::cout << i << " finish Destroy!!!!" << std::endl; 667 668 close(g_fdList[i]); 669 } 670 cout << "num: " << num << endl; 671 } 672 } 673 674 /** 675 * @tc.number : DEMUXER_FUNC_VTT_004 676 * @tc.name : create 16 instances repeat create-destory with vtt MP4 uri 677 * @tc.desc : function test 678 */ 679 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_004, TestSize.Level3) 680 { 681 int num = 0; 682 while (num < 10) { 683 num++; 684 vector<std::thread> vecThread; 685 const char *uri = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_en_GB_15.mp4"; 686 for (int i = 0; i < g_maxThread; i++) { 687 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 688 cout << i << " uri: " << uri << endl; 689 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 690 ASSERT_NE(source_list[i], nullptr); 691 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 692 ASSERT_NE(demuxer_list[i], nullptr); 693 vecThread.emplace_back(DemuxFuncVtt, i, num); 694 } 695 for (auto &val : vecThread) { 696 val.join(); 697 } 698 for (int i = 0; i < g_maxThread; i++) { 699 if (demuxer_list[i] != nullptr) { 700 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 701 demuxer_list[i] = nullptr; 702 } 703 704 if (source_list[i] != nullptr) { 705 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 706 source_list[i] = nullptr; 707 } 708 if (memory_list[i] != nullptr) { 709 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 710 memory_list[i] = nullptr; 711 } 712 std::cout << i << " finish Destroy!!!!" << std::endl; 713 } 714 cout << "num: " << num << endl; 715 } 716 } 717 /** 718 * @tc.number : DEMUXER_FUNC_VTT_005 719 * @tc.name : create vtt Mp4 demuxer with uri file and read 720 * @tc.desc : function test 721 */ 722 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_005, TestSize.Level0) 723 { 724 OH_AVCodecBufferAttr attr; 725 const char* mimeType = nullptr; 726 const char *uri = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_en_GB_15.mp4"; 727 const char *fileV = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_en_GB_15.vtt"; 728 cout << uri << "------" << endl; 729 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 730 ASSERT_NE(source, nullptr); 731 demuxer = OH_AVDemuxer_CreateWithSource(source); 732 ASSERT_NE(demuxer, nullptr); 733 sourceFormat = OH_AVSource_GetSourceFormat(source); 734 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 735 ASSERT_NE(trackFormat, nullptr); 736 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 737 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 738 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 739 ASSERT_EQ(1, g_trackCount); 740 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 741 int tarckType = 0; 742 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 743 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 744 MyMapVtt(0, fileV); 745 std::map<int64_t, int32_t>::iterator pair; 746 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 747 std::cout << pair->first << " => " << pair->second << '\n'; 748 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 749 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 750 ASSERT_NE(memory, nullptr); 751 ASSERT_NE(demuxer, nullptr); 752 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 753 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 754 break; 755 } 756 ASSERT_EQ(pair->second, attr.size); 757 } 758 } 759 /** 760 * @tc.number : DEMUXER_FUNC_VTT_006 761 * @tc.name : create vtt Mp4 demuxer with uri file and forward back seek+read 762 * @tc.desc : function test 763 */ 764 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_006, TestSize.Level0) 765 { 766 OH_AVCodecBufferAttr attr; 767 const char* mimeType = nullptr; 768 const char *uri = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_en_GB_15.mp4"; 769 const char *fileV = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_en_GB_15.vtt"; 770 cout << uri << "------" << endl; 771 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 772 ASSERT_NE(source, nullptr); 773 demuxer = OH_AVDemuxer_CreateWithSource(source); 774 ASSERT_NE(demuxer, nullptr); 775 sourceFormat = OH_AVSource_GetSourceFormat(source); 776 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 777 ASSERT_NE(trackFormat, nullptr); 778 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 779 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 780 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 781 ASSERT_EQ(1, g_trackCount); 782 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 783 int tarckType = 0; 784 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 785 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 786 for (int index = 0; index < 10; index++) { 787 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 788 } 789 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEMONOMP4 / ATTRPTS, 790 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 791 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 792 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEDUALMP4 / ATTRPTS, 793 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 794 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 795 MyMapVtt(BITRATEDUALMP4, fileV); 796 std::map<int64_t, int32_t>::iterator pair; 797 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 798 std::cout << pair->first << " => " << pair->second << '\n'; 799 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 800 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 801 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 802 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 803 break; 804 } 805 ASSERT_EQ(pair->second, attr.size); 806 } 807 } 808 809 /** 810 * @tc.number : DEMUXER_FUNC_VTT_007 811 * @tc.name : create 16 instances repeat create-destory with vtt MP4 file 812 * @tc.desc : function test 813 */ 814 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_007, TestSize.Level3) 815 { 816 int num = 0; 817 int len = 256; 818 while (num < 10) { 819 num++; 820 vector<std::thread> vecThread; 821 for (int i = 0; i < g_maxThread; i++) { 822 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 823 char file[256] = {}; 824 sprintf_s(file, len, "/data/test/media/16/%d_subtitle_webvtt_zh_CN_14.mp4", i); 825 g_fdList[i] = open(file, O_RDONLY); 826 int64_t size = GetFileSize(file); 827 cout << file << "----------------------" << g_fdList[i] << "---------" << size << endl; 828 829 source_list[i] = OH_AVSource_CreateWithFD(g_fdList[i], 0, size); 830 ASSERT_NE(source_list[i], nullptr); 831 832 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 833 ASSERT_NE(demuxer_list[i], nullptr); 834 vecThread.emplace_back(DemuxFuncVtt, i, num); 835 } 836 for (auto &val : vecThread) { 837 val.join(); 838 } 839 840 for (int i = 0; i < g_maxThread; i++) { 841 if (demuxer_list[i] != nullptr) { 842 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 843 demuxer_list[i] = nullptr; 844 } 845 846 if (source_list[i] != nullptr) { 847 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 848 source_list[i] = nullptr; 849 } 850 if (memory_list[i] != nullptr) { 851 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 852 memory_list[i] = nullptr; 853 } 854 std::cout << i << " finish Destroy!!!!" << std::endl; 855 856 close(g_fdList[i]); 857 } 858 cout << "num: " << num << endl; 859 } 860 } 861 862 /** 863 * @tc.number : DEMUXER_FUNC_VTT_008 864 * @tc.name : create 16 instances repeat create-destory with vtt MP4 uri 865 * @tc.desc : function test 866 */ 867 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_008, TestSize.Level3) 868 { 869 int num = 0; 870 while (num < 10) { 871 num++; 872 vector<std::thread> vecThread; 873 const char *uri = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_zh_CN_14.mp4"; 874 for (int i = 0; i < g_maxThread; i++) { 875 memory_list[i] = OH_AVMemory_Create(g_width * g_height); 876 cout << i << " uri: " << uri << endl; 877 source_list[i] = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 878 ASSERT_NE(source_list[i], nullptr); 879 demuxer_list[i] = OH_AVDemuxer_CreateWithSource(source_list[i]); 880 ASSERT_NE(demuxer_list[i], nullptr); 881 vecThread.emplace_back(DemuxFuncVtt, i, num); 882 } 883 for (auto &val : vecThread) { 884 val.join(); 885 } 886 for (int i = 0; i < g_maxThread; i++) { 887 if (demuxer_list[i] != nullptr) { 888 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer_list[i])); 889 demuxer_list[i] = nullptr; 890 } 891 892 if (source_list[i] != nullptr) { 893 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source_list[i])); 894 source_list[i] = nullptr; 895 } 896 if (memory_list[i] != nullptr) { 897 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory_list[i])); 898 memory_list[i] = nullptr; 899 } 900 std::cout << i << " finish Destroy!!!!" << std::endl; 901 } 902 cout << "num: " << num << endl; 903 } 904 } 905 /** 906 * @tc.number : DEMUXER_FUNC_VTT_009 907 * @tc.name : create vtt Mp4 demuxer with uri file and read 908 * @tc.desc : function test 909 */ 910 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_009, TestSize.Level0) 911 { 912 OH_AVCodecBufferAttr attr; 913 const char* mimeType = nullptr; 914 const char *uri = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_zh_CN_14.mp4"; 915 const char *fileV = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_zh_CN_14.vtt"; 916 cout << uri << "------" << endl; 917 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 918 ASSERT_NE(source, nullptr); 919 demuxer = OH_AVDemuxer_CreateWithSource(source); 920 ASSERT_NE(demuxer, nullptr); 921 sourceFormat = OH_AVSource_GetSourceFormat(source); 922 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 923 ASSERT_NE(trackFormat, nullptr); 924 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 925 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 926 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 927 ASSERT_EQ(1, g_trackCount); 928 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 929 int tarckType = 0; 930 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 931 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 932 MyMapVtt(0, fileV); 933 std::map<int64_t, int32_t>::iterator pair; 934 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 935 std::cout << pair->first << " => " << pair->second << '\n'; 936 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 937 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 938 ASSERT_NE(memory, nullptr); 939 ASSERT_NE(demuxer, nullptr); 940 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 941 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 942 break; 943 } 944 ASSERT_EQ(pair->second, attr.size); 945 } 946 } 947 /** 948 * @tc.number : DEMUXER_FUNC_VTT_0010 949 * @tc.name : create vtt Mp4 demuxer with uri file and forward back seek+read 950 * @tc.desc : function test 951 */ 952 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0010, TestSize.Level0) 953 { 954 OH_AVCodecBufferAttr attr; 955 const char* mimeType = nullptr; 956 const char *uri = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_zh_CN_14.mp4"; 957 const char *fileV = "http://192.168.3.11:8080/share/audio/subtitle_webvtt_zh_CN_14.vtt"; 958 cout << uri << "------" << endl; 959 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 960 ASSERT_NE(source, nullptr); 961 demuxer = OH_AVDemuxer_CreateWithSource(source); 962 ASSERT_NE(demuxer, nullptr); 963 sourceFormat = OH_AVSource_GetSourceFormat(source); 964 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 965 ASSERT_NE(trackFormat, nullptr); 966 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 967 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 968 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 969 ASSERT_EQ(1, g_trackCount); 970 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 971 int tarckType = 0; 972 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 973 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 974 for (int index = 0; index < 10; index++) { 975 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 976 } 977 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEMONO14 / ATTRPTS, 978 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 979 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 980 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEDUAL14 / ATTRPTS, 981 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 982 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 983 MyMapVtt(BITRATEDUAL14, fileV); 984 std::map<int64_t, int32_t>::iterator pair; 985 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 986 std::cout << pair->first << " => " << pair->second << '\n'; 987 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 988 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 989 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 990 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 991 break; 992 } 993 ASSERT_EQ(pair->second, attr.size); 994 } 995 } 996 /** 997 * @tc.number : DEMUXER_FUNC_VTT_0011 998 * @tc.name : create vtt demuxer with uri file and read 999 * @tc.desc : function test 1000 */ 1001 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0011, TestSize.Level0) 1002 { 1003 OH_AVCodecBufferAttr attr; 1004 const char* mimeType = nullptr; 1005 int vttIndex = 1; 1006 int vttSubtitle = 0; 1007 const char *uri = "http://192.168.3.11:8080/share/audio/webvtt_test.vtt"; 1008 cout << uri << "------" << endl; 1009 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1010 ASSERT_NE(source, nullptr); 1011 demuxer = OH_AVDemuxer_CreateWithSource(source); 1012 ASSERT_NE(demuxer, nullptr); 1013 sourceFormat = OH_AVSource_GetSourceFormat(source); 1014 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1015 ASSERT_NE(trackFormat, nullptr); 1016 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1017 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1018 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1019 ASSERT_EQ(1, g_trackCount); 1020 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1021 int tarckType = 0; 1022 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1023 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1024 while (true) { 1025 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1026 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1027 cout << " vtt is end !!!!!!!!!!!!!!!" << endl; 1028 break; 1029 } 1030 uint8_t *data = OH_AVMemory_GetAddr(memory); 1031 vttSubtitle = atoi(reinterpret_cast<const char*>(data)); 1032 ASSERT_EQ(vttSubtitle, vttIndex); 1033 vttIndex++; 1034 } 1035 } 1036 /** 1037 * @tc.number : DEMUXER_FUNC_VTT_0012 1038 * @tc.name : create vtt demuxer with uri file and forward back seek+read 1039 * @tc.desc : function test 1040 */ 1041 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0012, TestSize.Level0) 1042 { 1043 OH_AVCodecBufferAttr attr; 1044 const char* mimeType = nullptr; 1045 int vttIndex = 1; 1046 int vttSubtitle = 0; 1047 uint8_t *data = nullptr; 1048 const char *uri = "http://192.168.3.11:8080/share/audio/webvtt_test.vtt"; 1049 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri)); 1050 ASSERT_NE(source, nullptr); 1051 demuxer = OH_AVDemuxer_CreateWithSource(source); 1052 ASSERT_NE(demuxer, nullptr); 1053 sourceFormat = OH_AVSource_GetSourceFormat(source); 1054 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1055 ASSERT_NE(trackFormat, nullptr); 1056 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1057 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1058 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1059 ASSERT_EQ(1, g_trackCount); 1060 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1061 int tarckType = 0; 1062 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1063 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1064 for (int index = 0; index < 8; index++) { 1065 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1066 } 1067 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, VTTSEEKBACK, 1068 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1069 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1070 data = OH_AVMemory_GetAddr(memory); 1071 vttSubtitle = atoi(reinterpret_cast<const char*>(data)); 1072 vttIndex = 4; 1073 ASSERT_EQ(vttSubtitle, vttIndex); 1074 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, VTTSEEKFORWARD, 1075 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1076 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1077 data = OH_AVMemory_GetAddr(memory); 1078 vttSubtitle = atoi(reinterpret_cast<const char*>(data)); 1079 vttIndex = 7; 1080 ASSERT_EQ(vttSubtitle, vttIndex); 1081 while (true) { 1082 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1083 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1084 break; 1085 } 1086 data = OH_AVMemory_GetAddr(memory); 1087 vttSubtitle = atoi(reinterpret_cast<const char*>(data)); 1088 vttIndex++; 1089 ASSERT_EQ(vttSubtitle, vttIndex); 1090 } 1091 } 1092 /** 1093 * @tc.number : DEMUXER_FUNC_VTT_0013 1094 * @tc.name : create vtt demuxer with Mp4 file and read 1095 * @tc.desc : function test 1096 */ 1097 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0013, TestSize.Level0) 1098 { 1099 OH_AVCodecBufferAttr attr; 1100 const char *file = "/data/test/media/subtitle_webvtt_en_GB_15.mp4"; 1101 const char *fileV = "/data/test/media/subtitle_webvtt_en_GB_15.vtt"; 1102 int fd = open(file, O_RDONLY); 1103 int64_t size = GetFileSize(file); 1104 cout << file << "----------------------" << fd << "---------" << size << endl; 1105 source = OH_AVSource_CreateWithFD(fd, 0, size); 1106 ASSERT_NE(source, nullptr); 1107 demuxer = OH_AVDemuxer_CreateWithSource(source); 1108 ASSERT_NE(demuxer, nullptr); 1109 const char* mimeType = nullptr; 1110 sourceFormat = OH_AVSource_GetSourceFormat(source); 1111 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1112 ASSERT_NE(trackFormat, nullptr); 1113 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1114 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1115 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1116 ASSERT_EQ(1, g_trackCount); 1117 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1118 int tarckType = 0; 1119 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1120 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1121 MyMapVtt(0, fileV); 1122 std::map<int64_t, int32_t>::iterator pair; 1123 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1124 std::cout << pair->first << " => " << pair->second << '\n'; 1125 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1126 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1127 ASSERT_NE(memory, nullptr); 1128 ASSERT_NE(demuxer, nullptr); 1129 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1130 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1131 break; 1132 } 1133 ASSERT_EQ(pair->second, attr.size); 1134 } 1135 close(fd); 1136 } 1137 1138 /** 1139 * @tc.number : DEMUXER_FUNC_VTT_0014 1140 * @tc.name : create vtt demuxer with Mp4 file and read 1141 * @tc.desc : function test 1142 */ 1143 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0014, TestSize.Level0) 1144 { 1145 OH_AVCodecBufferAttr attr; 1146 const char *file = "/data/test/media/subtitle_webvtt_zh_CN_14.mp4"; 1147 const char *fileV = "/data/test/media/subtitle_webvtt_zh_CN_14.vtt"; 1148 int fd = open(file, O_RDONLY); 1149 int64_t size = GetFileSize(file); 1150 cout << file << "----------------------" << fd << "---------" << size << endl; 1151 source = OH_AVSource_CreateWithFD(fd, 0, size); 1152 ASSERT_NE(source, nullptr); 1153 demuxer = OH_AVDemuxer_CreateWithSource(source); 1154 ASSERT_NE(demuxer, nullptr); 1155 const char* mimeType = nullptr; 1156 sourceFormat = OH_AVSource_GetSourceFormat(source); 1157 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1158 ASSERT_NE(trackFormat, nullptr); 1159 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1160 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1161 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1162 ASSERT_EQ(1, g_trackCount); 1163 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1164 int tarckType = 0; 1165 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1166 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1167 MyMapVtt(0, fileV); 1168 std::map<int64_t, int32_t>::iterator pair; 1169 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1170 std::cout << pair->first << " => " << pair->second << '\n'; 1171 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1172 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1173 ASSERT_NE(memory, nullptr); 1174 ASSERT_NE(demuxer, nullptr); 1175 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1176 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1177 break; 1178 } 1179 ASSERT_EQ(pair->second, attr.size); 1180 } 1181 close(fd); 1182 } 1183 /** 1184 * @tc.number : DEMUXER_FUNC_VTT_0015 1185 * @tc.name : create vtt Mp4 demuxer with file and forward back seek+read 1186 * @tc.desc : function test 1187 */ 1188 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0015, TestSize.Level0) 1189 { 1190 OH_AVCodecBufferAttr attr; 1191 const char *file = "/data/test/media/subtitle_webvtt_en_GB_15.mp4"; 1192 const char *fileV = "/data/test/media/subtitle_webvtt_en_GB_15.vtt"; 1193 int fd = open(file, O_RDONLY); 1194 int64_t size = GetFileSize(file); 1195 cout << file << "----------------------" << fd << "---------" << size << endl; 1196 source = OH_AVSource_CreateWithFD(fd, 0, size); 1197 ASSERT_NE(source, nullptr); 1198 demuxer = OH_AVDemuxer_CreateWithSource(source); 1199 ASSERT_NE(demuxer, nullptr); 1200 const char* mimeType = nullptr; 1201 sourceFormat = OH_AVSource_GetSourceFormat(source); 1202 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1203 ASSERT_NE(trackFormat, nullptr); 1204 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1205 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1206 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1207 ASSERT_EQ(1, g_trackCount); 1208 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1209 int tarckType = 0; 1210 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1211 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1212 for (int index = 0; index < 10; index++) { 1213 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1214 } 1215 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEMONOMP4 / ATTRPTS, 1216 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1217 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1218 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEDUALMP4 / ATTRPTS, 1219 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1220 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1221 MyMapVtt(BITRATEDUALMP4, fileV); 1222 std::map<int64_t, int32_t>::iterator pair; 1223 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1224 std::cout << pair->first << " => " << pair->second << '\n'; 1225 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1226 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1227 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1228 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1229 break; 1230 } 1231 ASSERT_EQ(pair->second, attr.size); 1232 } 1233 close(fd); 1234 } 1235 1236 /** 1237 * @tc.number : DEMUXER_FUNC_VTT_0016 1238 * @tc.name : create vtt Mp4 demuxer with file and forward back seek+read 1239 * @tc.desc : function test 1240 */ 1241 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0016, TestSize.Level0) 1242 { 1243 OH_AVCodecBufferAttr attr; 1244 const char *file = "/data/test/media/subtitle_webvtt_zh_CN_14.mp4"; 1245 const char *fileV = "/data/test/media/subtitle_webvtt_zh_CN_14.vtt"; 1246 int fd = open(file, O_RDONLY); 1247 int64_t size = GetFileSize(file); 1248 cout << file << "----------------------" << fd << "---------" << size << endl; 1249 source = OH_AVSource_CreateWithFD(fd, 0, size); 1250 ASSERT_NE(source, nullptr); 1251 demuxer = OH_AVDemuxer_CreateWithSource(source); 1252 ASSERT_NE(demuxer, nullptr); 1253 const char* mimeType = nullptr; 1254 sourceFormat = OH_AVSource_GetSourceFormat(source); 1255 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1256 ASSERT_NE(trackFormat, nullptr); 1257 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1258 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1259 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1260 ASSERT_EQ(1, g_trackCount); 1261 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1262 int tarckType = 0; 1263 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1264 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1265 for (int index = 0; index < 10; index++) { 1266 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1267 } 1268 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEMONO14 / ATTRPTS, 1269 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1270 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1271 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEDUAL14 / ATTRPTS, 1272 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1273 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1274 MyMapVtt(BITRATEDUAL14, fileV); 1275 std::map<int64_t, int32_t>::iterator pair; 1276 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1277 std::cout << pair->first << " => " << pair->second << '\n'; 1278 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1279 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1280 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1281 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1282 break; 1283 } 1284 ASSERT_EQ(pair->second, attr.size); 1285 } 1286 close(fd); 1287 } 1288 1289 /** 1290 * @tc.number : DEMUXER_FUNC_VTT_0017 1291 * @tc.name : create vtt Mp4 demuxer with file and back seek+read 1292 * @tc.desc : function test 1293 */ 1294 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0017, TestSize.Level0) 1295 { 1296 OH_AVCodecBufferAttr attr; 1297 const char *file = "/data/test/media/subtitle_webvtt_en_GB_15.mp4"; 1298 const char *fileV = "/data/test/media/subtitle_webvtt_en_GB_15.vtt"; 1299 int fd = open(file, O_RDONLY); 1300 int64_t size = GetFileSize(file); 1301 cout << file << "----------------------" << fd << "---------" << size << endl; 1302 source = OH_AVSource_CreateWithFD(fd, 0, size); 1303 ASSERT_NE(source, nullptr); 1304 demuxer = OH_AVDemuxer_CreateWithSource(source); 1305 ASSERT_NE(demuxer, nullptr); 1306 const char* mimeType = nullptr; 1307 sourceFormat = OH_AVSource_GetSourceFormat(source); 1308 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1309 ASSERT_NE(trackFormat, nullptr); 1310 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1311 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1312 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1313 ASSERT_EQ(1, g_trackCount); 1314 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1315 int tarckType = 0; 1316 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1317 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1318 for (int index = 0; index < 10; index++) { 1319 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1320 } 1321 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEMONOMP4 / ATTRPTS, 1322 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1323 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1324 MyMapVtt(BITRATEMONOMP4, fileV); 1325 std::map<int64_t, int32_t>::iterator pair; 1326 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1327 std::cout << pair->first << " => " << pair->second << '\n'; 1328 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1329 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1330 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1331 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1332 break; 1333 } 1334 ASSERT_EQ(pair->second, attr.size); 1335 } 1336 close(fd); 1337 } 1338 /** 1339 * @tc.number : DEMUXER_FUNC_VTT_0018 1340 * @tc.name : create vtt Mp4 demuxer with file and back seek+read 1341 * @tc.desc : function test 1342 */ 1343 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0018, TestSize.Level0) 1344 { 1345 OH_AVCodecBufferAttr attr; 1346 const char *file = "/data/test/media/subtitle_webvtt_zh_CN_14.mp4"; 1347 const char *fileV = "/data/test/media/subtitle_webvtt_zh_CN_14.vtt"; 1348 int fd = open(file, O_RDONLY); 1349 int64_t size = GetFileSize(file); 1350 cout << file << "----------------------" << fd << "---------" << size << endl; 1351 source = OH_AVSource_CreateWithFD(fd, 0, size); 1352 ASSERT_NE(source, nullptr); 1353 demuxer = OH_AVDemuxer_CreateWithSource(source); 1354 ASSERT_NE(demuxer, nullptr); 1355 const char* mimeType = nullptr; 1356 sourceFormat = OH_AVSource_GetSourceFormat(source); 1357 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1358 ASSERT_NE(trackFormat, nullptr); 1359 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1360 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1361 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1362 ASSERT_EQ(1, g_trackCount); 1363 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1364 int tarckType = 0; 1365 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1366 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1367 for (int index = 0; index < 10; index++) { 1368 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1369 } 1370 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEMONO14 / ATTRPTS, 1371 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1372 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1373 MyMapVtt(BITRATEMONO14, fileV); 1374 std::map<int64_t, int32_t>::iterator pair; 1375 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1376 std::cout << pair->first << " => " << pair->second << '\n'; 1377 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1378 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1379 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1380 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1381 break; 1382 } 1383 ASSERT_EQ(pair->second, attr.size); 1384 } 1385 close(fd); 1386 } 1387 /** 1388 * @tc.number : DEMUXER_FUNC_VTT_0019 1389 * @tc.name : create vtt Mp4 demuxer with file and forward seek+read 1390 * @tc.desc : function test 1391 */ 1392 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0019, TestSize.Level0) 1393 { 1394 OH_AVCodecBufferAttr attr; 1395 const char *file = "/data/test/media/subtitle_webvtt_en_GB_15.mp4"; 1396 const char *fileV = "/data/test/media/subtitle_webvtt_en_GB_15.vtt"; 1397 int fd = open(file, O_RDONLY); 1398 int64_t size = GetFileSize(file); 1399 cout << file << "----------------------" << fd << "---------" << size << endl; 1400 source = OH_AVSource_CreateWithFD(fd, 0, size); 1401 ASSERT_NE(source, nullptr); 1402 demuxer = OH_AVDemuxer_CreateWithSource(source); 1403 ASSERT_NE(demuxer, nullptr); 1404 const char* mimeType = nullptr; 1405 sourceFormat = OH_AVSource_GetSourceFormat(source); 1406 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1407 ASSERT_NE(trackFormat, nullptr); 1408 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1409 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1410 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1411 ASSERT_EQ(1, g_trackCount); 1412 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1413 int tarckType = 0; 1414 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1415 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1416 for (int index = 0; index < 10; index++) { 1417 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1418 } 1419 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEDUALMP4 / ATTRPTS, 1420 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1421 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1422 MyMapVtt(BITRATEDUALMP4, fileV); 1423 std::map<int64_t, int32_t>::iterator pair; 1424 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1425 std::cout << pair->first << " => " << pair->second << '\n'; 1426 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1427 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1428 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1429 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1430 break; 1431 } 1432 ASSERT_EQ(pair->second, attr.size); 1433 } 1434 close(fd); 1435 } 1436 1437 /** 1438 * @tc.number : DEMUXER_FUNC_VTT_0020 1439 * @tc.name : create vtt Mp4 demuxer with file and forward seek+read 1440 * @tc.desc : function test 1441 */ 1442 HWTEST_F(DemuxerNetNdkTest, DEMUXER_FUNC_VTT_0020, TestSize.Level0) 1443 { 1444 OH_AVCodecBufferAttr attr; 1445 const char *file = "/data/test/media/subtitle_webvtt_zh_CN_14.mp4"; 1446 const char *fileV = "/data/test/media/subtitle_webvtt_zh_CN_14.vtt"; 1447 int fd = open(file, O_RDONLY); 1448 int64_t size = GetFileSize(file); 1449 cout << file << "----------------------" << fd << "---------" << size << endl; 1450 source = OH_AVSource_CreateWithFD(fd, 0, size); 1451 ASSERT_NE(source, nullptr); 1452 demuxer = OH_AVDemuxer_CreateWithSource(source); 1453 ASSERT_NE(demuxer, nullptr); 1454 const char* mimeType = nullptr; 1455 sourceFormat = OH_AVSource_GetSourceFormat(source); 1456 trackFormat = OH_AVSource_GetTrackFormat(source, 0); 1457 ASSERT_NE(trackFormat, nullptr); 1458 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &mimeType)); 1459 ASSERT_EQ(0, strcmp(mimeType, OH_AVCODEC_MIMETYPE_SUBTITLE_WEBVTT)); 1460 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount)); 1461 ASSERT_EQ(1, g_trackCount); 1462 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0)); 1463 int tarckType = 0; 1464 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType)); 1465 ASSERT_EQ(tarckType, OH_MediaType::MEDIA_TYPE_SUBTITLE); 1466 for (int index = 0; index < 10; index++) { 1467 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1468 } 1469 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, BITRATEDUAL14 / ATTRPTS, 1470 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1471 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1472 MyMapVtt(BITRATEDUAL14, fileV); 1473 std::map<int64_t, int32_t>::iterator pair; 1474 for (pair = myMap.begin(); pair != myMap.end(); ++pair) { 1475 std::cout << pair->first << " => " << pair->second << '\n'; 1476 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, pair->first / ATTRPTS, 1477 OH_AVSeekMode::SEEK_MODE_CLOSEST_SYNC)); 1478 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr)); 1479 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) { 1480 break; 1481 } 1482 ASSERT_EQ(pair->second, attr.size); 1483 } 1484 close(fd); 1485 } 1486} // namespace