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