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 }
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
1487