1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "native_avcodec_base.h"
19 #include "native_avdemuxer.h"
20 #include "native_avformat.h"
21 #include "native_avsource.h"
22 #include "native_avmemory.h"
23
24 #include <iostream>
25 #include <cstdio>
26 #include <string>
27 #include <fcntl.h>
28 #include <cmath>
29 #include <thread>
30 namespace OHOS {
31 namespace Media {
32 class DemuxerAviFuncNdkTest : public testing::Test {
33 public:
34 // SetUpTestCase: Called before all test cases
35 static void SetUpTestCase(void);
36 // TearDownTestCase: Called after all test case
37 static void TearDownTestCase(void);
38 // SetUp: Called before each test cases
39 void SetUp(void);
40 // TearDown: Called after each test cases
41 void TearDown(void);
42 protected:
43 const char *INP_DIR_1 = "/data/test/media/AVI_H263_baseline@level10_352_288_AAC_2.avi";
44 const char *INP_DIR_2 = "/data/test/media/AVI_H263_baseline@level20_352_288_MP2_1.avi";
45 const char *INP_DIR_3 = "/data/test/media/AVI_H263_baseline@level60_704_576_MP3_2.avi";
46 const char *INP_DIR_4 = "/data/test/media/AVI_H263_baseline@level70_1408_1152_PCM_mulaw_1.avi";
47 const char *INP_DIR_5 = "/data/test/media/AVI_H264_constrained_baseline@level4.1_1280_720_AAC_2.avi";
48 const char *INP_DIR_6 = "/data/test/media/AVI_H264_main@level5_1920_1080_MP2_1.avi";
49 const char *INP_DIR_7 = "/data/test/media/AVI_H264_high@level5.1_1920_1080_MP3_2.avi";
50 const char *INP_DIR_8 = "/data/test/media/AVI_H264_high@level5_2560_1920_PCM_mulaw_1.avi";
51 const char *INP_DIR_9 = "/data/test/media/AVI_MPEG2_simple@low_320_240_AAC_2.avi";
52 const char *INP_DIR_10 = "/data/test/media/AVI_MPEG2_main@mian_640_480_MP2_1.avi";
53 const char *INP_DIR_11 = "/data/test/media/AVI_MPEG2_simple@main_640_480_MP3_2.avi";
54 const char *INP_DIR_12 = "/data/test/media/AVI_MPEG2_422P@high_1920_1080_PCM_s24_1.avi";
55 const char *INP_DIR_13 = "/data/test/media/AVI_MPEG4_simple@level1_640_480_AAC_2.avi";
56 const char *INP_DIR_14 = "/data/test/media/AVI_MPEG4_advanced_simple@level6_1280_720_MP2_1.avi";
57 const char *INP_DIR_15 = "/data/test/media/AVI_MPEG4_advanced_simple@level3_352_288_MP3_2.avi";
58 const char *INP_DIR_16 = "/data/test/media/AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi";
59 };
60
61 static int g_fd = -1;
62 static OH_AVMemory *memory = nullptr;
63 static OH_AVSource *source = nullptr;
64 static OH_AVErrCode ret = AV_ERR_OK;
65 static OH_AVDemuxer *demuxer = nullptr;
66 static OH_AVFormat *sourceFormat = nullptr;
67 static OH_AVFormat *trackFormat = nullptr;
68 static OH_AVBuffer *avBuffer = nullptr;
69 static OH_AVFormat *format = nullptr;
70 static int32_t g_trackCount;
71 static int32_t g_width = 3840;
72 static int32_t g_height = 2160;
73 constexpr int32_t THOUSAND = 1000.0;
74 constexpr int32_t TWO = 2;
75 const std::string HEVC_LIB_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_hevc_parser.z.so";
SetUpTestCase()76 void DemuxerAviFuncNdkTest::SetUpTestCase() {}
TearDownTestCase()77 void DemuxerAviFuncNdkTest::TearDownTestCase() {}
SetUp()78 void DemuxerAviFuncNdkTest::SetUp()
79 {
80 memory = OH_AVMemory_Create(g_width * g_height);
81 g_trackCount = 0;
82 }
TearDown()83 void DemuxerAviFuncNdkTest::TearDown()
84 {
85 if (g_fd > 0) {
86 close(g_fd);
87 g_fd = -1;
88 }
89
90 if (trackFormat != nullptr) {
91 OH_AVFormat_Destroy(trackFormat);
92 trackFormat = nullptr;
93 }
94
95 if (sourceFormat != nullptr) {
96 OH_AVFormat_Destroy(sourceFormat);
97 sourceFormat = nullptr;
98 }
99 if (format != nullptr) {
100 OH_AVFormat_Destroy(format);
101 format = nullptr;
102 }
103
104 if (memory != nullptr) {
105 OH_AVMemory_Destroy(memory);
106 memory = nullptr;
107 }
108 if (source != nullptr) {
109 OH_AVSource_Destroy(source);
110 source = nullptr;
111 }
112 if (demuxer != nullptr) {
113 OH_AVDemuxer_Destroy(demuxer);
114 demuxer = nullptr;
115 }
116 if (avBuffer != nullptr) {
117 OH_AVBuffer_Destroy(avBuffer);
118 avBuffer = nullptr;
119 }
120 }
121 } // namespace Media
122 } // namespace OHOS
123
124 using namespace std;
125 using namespace OHOS;
126 using namespace OHOS::Media;
127 using namespace testing::ext;
128
GetFileSize(const char * fileName)129 static int64_t GetFileSize(const char *fileName)
130 {
131 int64_t fileSize = 0;
132 if (fileName != nullptr) {
133 struct stat fileStatus {};
134 if (stat(fileName, &fileStatus) == 0) {
135 fileSize = static_cast<int64_t>(fileStatus.st_size);
136 }
137 }
138 return fileSize;
139 }
140
141 struct seekInfo {
142 const char *fileName;
143 OH_AVSeekMode seekmode;
144 int64_t millisecond;
145 int32_t videoCount;
146 int32_t audioCount;
147 };
148
CheckSeekModefromEnd(seekInfo seekInfo)149 static void CheckSeekModefromEnd(seekInfo seekInfo)
150 {
151 int tarckType = 0;
152 g_fd = open(seekInfo.fileName, O_RDONLY);
153 int64_t size = GetFileSize(seekInfo.fileName);
154 cout << seekInfo.fileName << "-------" << g_fd << "-------" << size << endl;
155 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
156 ASSERT_NE(source, nullptr);
157 demuxer = OH_AVDemuxer_CreateWithSource(source);
158 ASSERT_NE(demuxer, nullptr);
159 sourceFormat = OH_AVSource_GetSourceFormat(source);
160 ASSERT_NE(sourceFormat, nullptr);
161 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
162 cout << "g_trackCount----" << g_trackCount << endl;
163 for (int32_t index = 0; index < g_trackCount; index++) {
164 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index));
165 }
166 for (int32_t index = 0; index < g_trackCount; index++) {
167 trackFormat = OH_AVSource_GetTrackFormat(source, index);
168 ASSERT_NE(trackFormat, nullptr);
169 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType));
170 ASSERT_EQ(AV_ERR_UNKNOWN, OH_AVDemuxer_SeekToTime(demuxer, seekInfo.millisecond / THOUSAND, seekInfo.seekmode));
171 }
172 close(g_fd);
173 g_fd = -1;
174 }
175
CheckSeekMode(seekInfo seekInfo)176 static void CheckSeekMode(seekInfo seekInfo)
177 {
178 int tarckType = 0;
179 OH_AVCodecBufferAttr attr;
180 g_fd = open(seekInfo.fileName, O_RDONLY);
181 int64_t size = GetFileSize(seekInfo.fileName);
182 cout << seekInfo.fileName << "-------" << g_fd << "-------" << size << endl;
183 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
184 ASSERT_NE(source, nullptr);
185 demuxer = OH_AVDemuxer_CreateWithSource(source);
186 ASSERT_NE(demuxer, nullptr);
187 sourceFormat = OH_AVSource_GetSourceFormat(source);
188 ASSERT_NE(sourceFormat, nullptr);
189 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
190 cout << "g_trackCount----" << g_trackCount << endl;
191 for (int32_t index = 0; index < g_trackCount; index++) {
192 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index));
193 }
194 for (int32_t index = 0; index < g_trackCount; index++) {
195 trackFormat = OH_AVSource_GetTrackFormat(source, index);
196 ASSERT_NE(trackFormat, nullptr);
197 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType));
198 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SeekToTime(demuxer, seekInfo.millisecond / THOUSAND, seekInfo.seekmode));
199 bool readEnd = false;
200 int32_t frameNum = 0;
201 while (!readEnd) {
202 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr));
203 //cout << "frameNum---" << frameNum << "---PTS---" << attr.pts << "---tarckType---" << tarckType << endl;
204 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) {
205 readEnd = true;
206 break;
207 }
208 frameNum++;
209 }
210 if (tarckType == MEDIA_TYPE_VID) {
211 cout << "frameNum---" << frameNum << endl;
212 ASSERT_EQ(seekInfo.videoCount, frameNum);
213 } else if (tarckType == MEDIA_TYPE_AUD) {
214 cout << "frameNum---" << frameNum << endl;
215 ASSERT_EQ(seekInfo.audioCount, frameNum);
216 }
217 }
218 close(g_fd);
219 g_fd = -1;
220 }
221
SetAudioValue(OH_AVCodecBufferAttr attr,bool & audioIsEnd,int & audioFrame,int & aKeyCount)222 static void SetAudioValue(OH_AVCodecBufferAttr attr, bool &audioIsEnd, int &audioFrame, int &aKeyCount)
223 {
224 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) {
225 audioIsEnd = true;
226 cout << audioFrame << " audio is end !!!!!!!!!!!!!!!" << endl;
227 } else {
228 audioFrame++;
229 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) {
230 aKeyCount++;
231 }
232 }
233 }
234
SetVideoValue(OH_AVCodecBufferAttr attr,bool & videoIsEnd,int & videoFrame,int & vKeyCount)235 static void SetVideoValue(OH_AVCodecBufferAttr attr, bool &videoIsEnd, int &videoFrame, int &vKeyCount)
236 {
237 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) {
238 videoIsEnd = true;
239 cout << videoFrame << " video is end !!!!!!!!!!!!!!!" << endl;
240 } else {
241 videoFrame++;
242 cout << "video track !!!!!" << endl;
243 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_SYNC_FRAME) {
244 vKeyCount++;
245 }
246 }
247 }
248
DemuxerResult(const char * fileName)249 static void DemuxerResult(const char *fileName)
250 {
251 int tarckType = 0;
252 OH_AVCodecBufferAttr attr;
253 bool audioIsEnd = false;
254 bool videoIsEnd = false;
255 int audioFrame = 0;
256 int videoFrame = 0;
257 g_fd = open(fileName, O_RDONLY);
258 int64_t size = GetFileSize(fileName);
259 cout << fileName << "----------------------" << g_fd << "---------" << size << endl;
260 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
261 ASSERT_NE(source, nullptr);
262 demuxer = OH_AVDemuxer_CreateWithSource(source);
263 ASSERT_NE(demuxer, nullptr);
264 sourceFormat = OH_AVSource_GetSourceFormat(source);
265 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
266 ASSERT_EQ(g_trackCount, TWO);
267 for (int32_t index = 0; index < g_trackCount; index++) {
268 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index));
269 }
270 int aKeyCount = 0;
271 int vKeyCount = 0;
272 while (!audioIsEnd || !videoIsEnd) {
273 for (int32_t index = 0; index < g_trackCount; index++) {
274 trackFormat = OH_AVSource_GetTrackFormat(source, index);
275 ASSERT_NE(trackFormat, nullptr);
276 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType));
277 OH_AVFormat_Destroy(trackFormat);
278 trackFormat = nullptr;
279 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) {
280 continue;
281 }
282 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr));
283 if (tarckType == MEDIA_TYPE_AUD) {
284 SetAudioValue(attr, audioIsEnd, audioFrame, aKeyCount);
285 } else if (tarckType == MEDIA_TYPE_VID) {
286 SetVideoValue(attr, videoIsEnd, videoFrame, vKeyCount);
287 }
288 }
289 }
290 close(g_fd);
291 g_fd = -1;
292 }
293
294 /**
295 * @tc.number : DEMUXER_AVI_FUNC_0100
296 * @tc.name : demuxer AVI ,GetVideoTrackFormat,MD_KEY_HEIGHT
297 * @tc.desc : function test
298 */
299 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0100, TestSize.Level2)
300 {
301 int32_t height = 0;
302 const char *file = INP_DIR_1;
303 g_fd = open(file, O_RDONLY);
304 int64_t size = GetFileSize(file);
305 cout << file << "----------------------" << g_fd << "---------" << size << endl;
306 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
307 ASSERT_NE(source, nullptr);
308 trackFormat = OH_AVSource_GetTrackFormat(source, 0);
309 ASSERT_NE(trackFormat, nullptr);
310 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_HEIGHT, &height));
311 ASSERT_EQ(height, 288);
312 close(g_fd);
313 }
314
315 /**
316 * @tc.number : DEMUXER_AVI_FUNC_0200
317 * @tc.name : demuxer AVI ,GetVideoTrackFormat,MD_KEY_WIDTHs
318 * @tc.desc : function test
319 */
320 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0200, TestSize.Level2)
321 {
322 int32_t weight = 0;
323 const char *file = INP_DIR_1;
324 g_fd = open(file, O_RDONLY);
325 int64_t size = GetFileSize(file);
326 cout << file << "----------------------" << g_fd << "---------" << size << endl;
327 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
328 ASSERT_NE(source, nullptr);
329 trackFormat = OH_AVSource_GetTrackFormat(source, 0);
330 ASSERT_NE(trackFormat, nullptr);
331 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_WIDTH, &weight));
332 ASSERT_EQ(weight, 352);
333 close(g_fd);
334 }
335
336 /**
337 * @tc.number : DEMUXER_AVI_FUNC_0300
338 * @tc.name : demuxer avi ,check source format,OH_MD_KEY_TITLE
339 * @tc.desc : function test
340 */
341 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0300, TestSize.Level2)
342 {
343 const char *stringVal;
344 const char *file = INP_DIR_1;
345 g_fd = open(file, O_RDONLY);
346 int64_t size = GetFileSize(file);
347 cout << file << "----------------------" << g_fd << "---------" << size << endl;
348 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
349 ASSERT_NE(source, nullptr);
350 sourceFormat = OH_AVSource_GetSourceFormat(source);
351 ASSERT_NE(sourceFormat, nullptr);
352 ASSERT_TRUE(OH_AVFormat_GetStringValue(sourceFormat, OH_MD_KEY_TITLE, &stringVal));
353 ASSERT_EQ(0, strcmp(stringVal, "title"));
354 close(g_fd);
355 }
356
357 /**
358 * @tc.number : DEMUXER_AVI_FUNC_0400
359 * @tc.name : demuxer avi ,check source format,OH_MD_KEY_ALBUM_ARTIST
360 * @tc.desc : function test
361 */
362 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0400, TestSize.Level2)
363 {
364 const char *file = INP_DIR_1;
365 g_fd = open(file, O_RDONLY);
366 int64_t size = GetFileSize(file);
367 cout << file << "----------------------" << g_fd << "---------" << size << endl;
368 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
369 ASSERT_NE(source, nullptr);
370 sourceFormat = OH_AVSource_GetSourceFormat(source);
371 ASSERT_NE(sourceFormat, nullptr);
372 const char *stringVal;
373 ASSERT_FALSE(OH_AVFormat_GetStringValue(sourceFormat, OH_MD_KEY_ALBUM_ARTIST, &stringVal));
374 close(g_fd);
375 }
376
377 /**
378 * @tc.number : DEMUXER_AVI_FUNC_0500
379 * @tc.name : demuxer avi ,check track format,OH_MD_KEY_DATE
380 * @tc.desc : function test
381 */
382 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0500, TestSize.Level2)
383 {
384 const char *file = INP_DIR_1;
385 g_fd = open(file, O_RDONLY);
386 int64_t size = GetFileSize(file);
387 cout << file << "----------------------" << g_fd << "---------" << size << endl;
388 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
389 ASSERT_NE(source, nullptr);
390 sourceFormat = OH_AVSource_GetSourceFormat(source);
391 ASSERT_NE(sourceFormat, nullptr);
392 const char *stringVal;
393 ASSERT_TRUE(OH_AVFormat_GetStringValue(sourceFormat, OH_MD_KEY_DATE, &stringVal));
394 ASSERT_EQ(0, strcmp(stringVal, "2023"));
395 close(g_fd);
396 }
397
398 /**
399 * @tc.number : DEMUXER_AVI_FUNC_0600
400 * @tc.name : demuxer avi ,check track format,OH_MD_KEY_COMMENT
401 * @tc.desc : function test
402 */
403 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0600, TestSize.Level2)
404 {
405 const char *file = INP_DIR_1;
406 g_fd = open(file, O_RDONLY);
407 int64_t size = GetFileSize(file);
408 cout << file << "----------------------" << g_fd << "---------" << size << endl;
409 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
410 ASSERT_NE(source, nullptr);
411 sourceFormat = OH_AVSource_GetSourceFormat(source);
412 ASSERT_NE(sourceFormat, nullptr);
413 const char *stringVal;
414 ASSERT_TRUE(OH_AVFormat_GetStringValue(sourceFormat, OH_MD_KEY_COMMENT, &stringVal));
415 ASSERT_EQ(0, strcmp(stringVal, "COMMENT"));
416 close(g_fd);
417 }
418
419 /**
420 * @tc.number : DEMUXER_AVI_FUNC_0700
421 * @tc.name : demuxer avi ,check track format,OH_MD_KEY_GENRE
422 * @tc.desc : function test
423 */
424 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0700, TestSize.Level2)
425 {
426 const char *file = INP_DIR_1;
427 g_fd = open(file, O_RDONLY);
428 int64_t size = GetFileSize(file);
429 cout << file << "----------------------" << g_fd << "---------" << size << endl;
430 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
431 ASSERT_NE(source, nullptr);
432 sourceFormat = OH_AVSource_GetSourceFormat(source);
433 ASSERT_NE(sourceFormat, nullptr);
434 const char *stringVal;
435 ASSERT_TRUE(OH_AVFormat_GetStringValue(sourceFormat, OH_MD_KEY_GENRE, &stringVal));
436 ASSERT_EQ(0, strcmp(stringVal, "Classical"));
437 close(g_fd);
438 }
439
440 /**
441 * @tc.number : DEMUXER_AVI_FUNC_0800
442 * @tc.name : demuxer avi ,check track format,OH_MD_KEY_COPYRIGHT
443 * @tc.desc : function test
444 */
445 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0800, TestSize.Level2)
446 {
447 const char *file = INP_DIR_1;
448 g_fd = open(file, O_RDONLY);
449 int64_t size = GetFileSize(file);
450 cout << file << "----------------------" << g_fd << "---------" << size << endl;
451 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
452 ASSERT_NE(source, nullptr);
453 sourceFormat = OH_AVSource_GetSourceFormat(source);
454 ASSERT_NE(sourceFormat, nullptr);
455 const char *stringVal;
456 ASSERT_TRUE(OH_AVFormat_GetStringValue(sourceFormat, OH_MD_KEY_COPYRIGHT, &stringVal));
457 close(g_fd);
458 }
459
460 /**
461 * @tc.number : DEMUXER_AVI_FUNC_0900
462 * @tc.name : demuxer avi ,GetSourceFormat,OH_MD_KEY_TRACK_COUNT
463 * @tc.desc : function test
464 */
465 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_0900, TestSize.Level2)
466 {
467 const char *file = INP_DIR_1;
468 g_fd = open(file, O_RDONLY);
469 int64_t size = GetFileSize(file);
470 cout << file << "----------------------" << g_fd << "---------" << size << endl;
471 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
472 ASSERT_NE(source, nullptr);
473
474 sourceFormat = OH_AVSource_GetSourceFormat(source);
475 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
476 ASSERT_EQ(g_trackCount, TWO);
477 close(g_fd);
478 }
479
480 /**
481 * @tc.number : DEMUXER_AVI_FUNC_1000
482 * @tc.name : demuxer avi ,GetAudioTrackFormat ,MD_KEY_BITRATE
483 * @tc.desc : function test
484 */
485 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1000, TestSize.Level2)
486 {
487 int64_t br = 0;
488 const char *file = INP_DIR_1;
489 g_fd = open(file, O_RDONLY);
490 int64_t size = GetFileSize(file);
491 cout << file << "----------------------" << g_fd << "---------" << size << endl;
492 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
493 ASSERT_NE(source, nullptr);
494 trackFormat = OH_AVSource_GetTrackFormat(source, 0);
495 ASSERT_NE(trackFormat, nullptr);
496 ASSERT_TRUE(OH_AVFormat_GetLongValue(trackFormat, OH_MD_KEY_BITRATE, &br));
497 ASSERT_EQ(br, 1092058);
498 close(g_fd);
499 }
500
501 /**
502 * @tc.number : DEMUXER_AVI_FUNC_1100
503 * @tc.name : demuxer avi ,GetAudioTrackFormat,MD_KEY_CHANNEL_COUNT
504 * @tc.desc : function test
505 */
506 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1100, TestSize.Level2)
507 {
508 int32_t cc = 0;
509 const char *file = INP_DIR_1;
510 g_fd = open(file, O_RDONLY);
511 int64_t size = GetFileSize(file);
512 cout << file << "----------------------" << g_fd << "---------" << size << endl;
513 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
514 ASSERT_NE(source, nullptr);
515 trackFormat = OH_AVSource_GetTrackFormat(source, 1);
516 ASSERT_NE(trackFormat, nullptr);
517 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_AUD_CHANNEL_COUNT, &cc));
518 ASSERT_EQ(cc, 2);
519 close(g_fd);
520 }
521
522 /**
523 * @tc.number : DEMUXER_AVI_FUNC_1200
524 * @tc.name : demuxer avi ,GetAudioTrackFormat,MD_KEY_SAMPLE_RATE
525 * @tc.desc : function test
526 */
527 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1200, TestSize.Level2)
528 {
529 int32_t sr = 0;
530 const char *file = INP_DIR_1;
531 g_fd = open(file, O_RDONLY);
532 int64_t size = GetFileSize(file);
533 cout << file << "----------------------" << g_fd << "---------" << size << endl;
534 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
535 ASSERT_NE(source, nullptr);
536 trackFormat = OH_AVSource_GetTrackFormat(source, 1);
537 ASSERT_NE(trackFormat, nullptr);
538 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_AUD_SAMPLE_RATE, &sr));
539 ASSERT_EQ(sr, 48000);
540 close(g_fd);
541 }
542
543 /**
544 * @tc.number : DEMUXER_AVI_FUNC_1300
545 * @tc.name : demuxer avi GetPublicTrackFormat,MD_KEY_CODEC_MIME
546 * @tc.desc : function test
547 */
548 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1300, TestSize.Level2)
549 {
550 const char *stringVal;
551 const char *file = INP_DIR_13;
552 g_fd = open(file, O_RDONLY);
553 int64_t size = GetFileSize(file);
554 cout << file << "----------------------" << g_fd << "---------" << size << endl;
555 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
556 ASSERT_NE(source, nullptr);
557 trackFormat = OH_AVSource_GetTrackFormat(source, 0);
558 ASSERT_NE(trackFormat, nullptr);
559 ASSERT_TRUE(OH_AVFormat_GetStringValue(trackFormat, OH_MD_KEY_CODEC_MIME, &stringVal));
560 ASSERT_EQ(0, strcmp(stringVal, OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2));
561 close(g_fd);
562 }
563
564 /**
565 * @tc.number : DEMUXER_AVI_FUNC_1400
566 * @tc.name : demuxer avi ,GetPublicTrackFormat,MD_KEY_TRACK_TYPE
567 * @tc.desc : function test
568 */
569 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1400, TestSize.Level2)
570 {
571 int32_t type = 0;
572 const char *file = INP_DIR_1;
573 g_fd = open(file, O_RDONLY);
574 int64_t size = GetFileSize(file);
575 cout << file << "----------------------" << g_fd << "---------" << size << endl;
576 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
577 ASSERT_NE(source, nullptr);
578 trackFormat = OH_AVSource_GetTrackFormat(source, 1);
579 ASSERT_NE(trackFormat, nullptr);
580 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &type));
581 ASSERT_EQ(type, MEDIA_TYPE_AUD);
582 close(g_fd);
583 }
584
585 /**
586 * @tc.number : DEMUXER_AVI_FUNC_1500
587 * @tc.name : create source with g_fd,avcc avi
588 * @tc.desc : function test
589 */
590 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1500, TestSize.Level2)
591 {
592 int tarckType = 0;
593 OH_AVCodecBufferAttr attr;
594 bool audioIsEnd = false;
595 bool videoIsEnd = false;
596 int audioFrame = 0;
597 int videoFrame = 0;
598 const char *file = INP_DIR_7;
599 g_fd = open(file, O_RDONLY);
600 int64_t size = GetFileSize(file);
601 cout << file << "----------------------" << g_fd << "---------" << size << endl;
602 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
603 ASSERT_NE(source, nullptr);
604 demuxer = OH_AVDemuxer_CreateWithSource(source);
605 ASSERT_NE(demuxer, nullptr);
606 sourceFormat = OH_AVSource_GetSourceFormat(source);
607 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
608 ASSERT_EQ(g_trackCount, TWO);
609 for (int32_t index = 0; index < g_trackCount; index++) {
610 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index));
611 }
612 int aKeyCount = 0;
613 int vKeyCount = 0;
614 while (!audioIsEnd || !videoIsEnd) {
615 for (int32_t index = 0; index < g_trackCount; index++) {
616 trackFormat = OH_AVSource_GetTrackFormat(source, index);
617 ASSERT_NE(trackFormat, nullptr);
618 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType));
619 OH_AVFormat_Destroy(trackFormat);
620 trackFormat = nullptr;
621 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) {
622 continue;
623 }
624 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr));
625
626 if (tarckType == MEDIA_TYPE_AUD) {
627 SetAudioValue(attr, audioIsEnd, audioFrame, aKeyCount);
628 } else if (tarckType == MEDIA_TYPE_VID) {
629 SetVideoValue(attr, videoIsEnd, videoFrame, vKeyCount);
630 }
631 }
632 }
633 ASSERT_EQ(audioFrame, 14);
634 ASSERT_EQ(videoFrame, 26);
635 ASSERT_EQ(aKeyCount, 14);
636 ASSERT_EQ(vKeyCount, 1);
637 close(g_fd);
638 }
639
640 /**
641 * @tc.number : DEMUXER_AVI_FUNC_1600
642 * @tc.name : create source with g_fd,AVI_H263_baseline@level10_352_288_AAC_2.avi
643 * @tc.desc : function test
644 */
645 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1600, TestSize.Level3)
646 {
647 DemuxerResult(INP_DIR_1);
648 }
649
650 /**
651 * @tc.number : DEMUXER_AVI_FUNC_1700
652 * @tc.name : create source with g_fd,AVI_H263_baseline@level20_352_288_MP2_1.avi
653 * @tc.desc : function test
654 */
655 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1700, TestSize.Level3)
656 {
657 DemuxerResult(INP_DIR_2);
658 }
659
660 /**
661 * @tc.number : DEMUXER_AVI_FUNC_1800
662 * @tc.name : create source with g_fd,AVI_H263_baseline@level60_704_576_MP3_2.avi
663 * @tc.desc : function test
664 */
665 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1800, TestSize.Level3)
666 {
667 DemuxerResult(INP_DIR_3);
668 }
669
670 /**
671 * @tc.number : DEMUXER_AVI_FUNC_1900
672 * @tc.name : create source with g_fd,AVI_H263_baseline@level70_1408_1152_PCM_mulaw_1.avi
673 * @tc.desc : function test
674 */
675 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_1900, TestSize.Level3)
676 {
677 DemuxerResult(INP_DIR_4);
678 }
679
680 /**
681 * @tc.number : DEMUXER_AVI_FUNC_2000
682 * @tc.name : create source with g_fd,AVI_H264_baseline@level4.1_1280_720_AAC_2.avi
683 * @tc.desc : function test
684 */
685 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2000, TestSize.Level3)
686 {
687 DemuxerResult(INP_DIR_5);
688 }
689
690 /**
691 * @tc.number : DEMUXER_AVI_FUNC_2100
692 * @tc.name : create source with g_fd,AVI_H264_main@level5_1920_1080_PM2_1.avi
693 * @tc.desc : function test
694 */
695 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2100, TestSize.Level3)
696 {
697 DemuxerResult(INP_DIR_6);
698 }
699
700 /**
701 * @tc.number : DEMUXER_AVI_FUNC_2200
702 * @tc.name : create source with g_fd,AVI_H264_high@level5.1_1920_1080_PM3_2.avi
703 * @tc.desc : function test
704 */
705 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2200, TestSize.Level3)
706 {
707 DemuxerResult(INP_DIR_7);
708 }
709
710 /**
711 * @tc.number : DEMUXER_AVI_FUNC_2300
712 * @tc.name : create source with g_fd,AVI_H264_h422@level5.1_2560_1920_PCM_mulaw_1.avi
713 * @tc.desc : function test
714 */
715 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2300, TestSize.Level3)
716 {
717 DemuxerResult(INP_DIR_8);
718 }
719
720 /**
721 * @tc.number : DEMUXER_AVI_FUNC_2400
722 * @tc.name : create source with g_fd,AVI_MPEG2_simple@low_320_240_AAC_2.avi
723 * @tc.desc : function test
724 */
725 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2400, TestSize.Level3)
726 {
727 DemuxerResult(INP_DIR_9);
728 }
729
730 /**
731 * @tc.number : DEMUXER_AVI_FUNC_2500
732 * @tc.name : create source with g_fd,AVI_MPEG2_main@mian_720_480_MP2_1.avi
733 * @tc.desc : function test
734 */
735 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2500, TestSize.Level3)
736 {
737 DemuxerResult(INP_DIR_10);
738 }
739
740 /**
741 * @tc.number : DEMUXER_AVI_FUNC_2600
742 * @tc.name : create source with g_fd,AVI_MPEG2_high@high_1440_1080_MP3_2.avi
743 * @tc.desc : function test
744 */
745 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2600, TestSize.Level3)
746 {
747 DemuxerResult(INP_DIR_11);
748 }
749
750 /**
751 * @tc.number : DEMUXER_AVI_FUNC_2700
752 * @tc.name : create source with g_fd,AVI_MPEG2_422P@high_1920_1080_PCM_s24_1.avi
753 * @tc.desc : function test
754 */
755 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2700, TestSize.Level3)
756 {
757 DemuxerResult(INP_DIR_12);
758 }
759
760 /**
761 * @tc.number : DEMUXER_AVI_FUNC_2800
762 * @tc.name : create source with g_fd,AVI_MPEG4_simple@level5_720_480_AAC_2.avi
763 * @tc.desc : function test
764 */
765 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2800, TestSize.Level3)
766 {
767 DemuxerResult(INP_DIR_13);
768 }
769
770 /**
771 * @tc.number : DEMUXER_AVI_FUNC_2900
772 * @tc.name : create source with g_fd,AVI_MPEG4_advanced_simple@level6_1280_720_MP2_1.avi
773 * @tc.desc : function test
774 */
775 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_2900, TestSize.Level3)
776 {
777 DemuxerResult(INP_DIR_14);
778 }
779
780 /**
781 * @tc.number : DEMUXER_AVI_FUNC_3000
782 * @tc.name : create source with g_fd,AVI_MPEG4_advanced_simple@level3_352_288_MP3_2.avi
783 * @tc.desc : function test
784 */
785 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3000, TestSize.Level3)
786 {
787 DemuxerResult(INP_DIR_15);
788 }
789
790 /**
791 * @tc.number : DEMUXER_AVI_FUNC_3100
792 * @tc.name : create source with g_fd,AVI_MPEG4_main@level5_720_576_PCM_s32_1.avi
793 * @tc.desc : function test
794 */
795 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3100, TestSize.Level3)
796 {
797 DemuxerResult(INP_DIR_16);
798 }
799
800 /**
801 * @tc.number : DEMUXER_AVI_FUNC_3200
802 * @tc.name : seek to the start time, previous mode
803 * @tc.desc : function test
804 */
805 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3200, TestSize.Level1)
806 {
807 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_PREVIOUS_SYNC, 0, 29, 47};
808 CheckSeekMode(fileTest1);
809 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 39};
810 CheckSeekMode(fileTest2);
811 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_PREVIOUS_SYNC, 0, 28, 39};
812 CheckSeekMode(fileTest3);
813 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 19};
814 CheckSeekMode(fileTest4);
815 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_PREVIOUS_SYNC, 0, 29, 44};
816 CheckSeekMode(fileTest5);
817 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 42};
818 CheckSeekMode(fileTest6);
819 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_PREVIOUS_SYNC, 0, 26, 14};
820 CheckSeekMode(fileTest7);
821 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_PREVIOUS_SYNC, 0, 12, 21};
822 CheckSeekMode(fileTest8);
823 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 47};
824 CheckSeekMode(fileTest9);
825 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 39};
826 CheckSeekMode(fileTest10);
827 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 43};
828 CheckSeekMode(fileTest11);
829 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 17};
830 CheckSeekMode(fileTest12);
831 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_PREVIOUS_SYNC, 0, 29, 45};
832 CheckSeekMode(fileTest13);
833 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 42};
834 CheckSeekMode(fileTest14);
835 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_PREVIOUS_SYNC, 0, 24, 14};
836 CheckSeekMode(fileTest15);
837 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_PREVIOUS_SYNC, 0, 30, 44};
838 CheckSeekMode(fileTest16);
839 }
840
841 /**
842 * @tc.number : DEMUXER_AVI_FUNC_3300
843 * @tc.name : seek to the start time, next mode
844 * @tc.desc : function test
845 */
846 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3300, TestSize.Level1)
847 {
848 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_NEXT_SYNC, 0, 29, 47};
849 CheckSeekMode(fileTest1);
850 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_NEXT_SYNC, 0, 30, 39};
851 CheckSeekMode(fileTest2);
852 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_NEXT_SYNC, 0, 28, 39};
853 CheckSeekMode(fileTest3);
854 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_NEXT_SYNC, 0, 30, 19};
855 CheckSeekMode(fileTest4);
856 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_NEXT_SYNC, 0, 29, 44};
857 CheckSeekMode(fileTest5);
858 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_NEXT_SYNC, 0, 30, 42};
859 CheckSeekMode(fileTest6);
860 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_NEXT_SYNC, 0, 26, 14};
861 CheckSeekMode(fileTest7);
862 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_NEXT_SYNC, 0, 12, 21};
863 CheckSeekMode(fileTest8);
864 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_NEXT_SYNC, 0, 30, 47};
865 CheckSeekMode(fileTest9);
866 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_NEXT_SYNC, 0, 30, 39};
867 CheckSeekMode(fileTest10);
868 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_NEXT_SYNC, 0, 30, 43};
869 CheckSeekMode(fileTest11);
870 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_NEXT_SYNC, 0, 30, 17};
871 CheckSeekMode(fileTest12);
872 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_NEXT_SYNC, 0, 29, 45};
873 CheckSeekMode(fileTest13);
874 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_NEXT_SYNC, 0, 30, 42};
875 CheckSeekMode(fileTest14);
876 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_NEXT_SYNC, 0, 24, 14};
877 CheckSeekMode(fileTest15);
878 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_NEXT_SYNC, 0, 30, 44};
879 CheckSeekMode(fileTest16);
880 }
881
882 /**
883 * @tc.number : DEMUXER_AVI_FUNC_3400
884 * @tc.name : seek to the start time, closest mode
885 * @tc.desc : function test
886 */
887 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3400, TestSize.Level1)
888 {
889 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_CLOSEST_SYNC, 0, 29, 47};
890 CheckSeekMode(fileTest1);
891 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_CLOSEST_SYNC, 0, 30, 39};
892 CheckSeekMode(fileTest2);
893 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_CLOSEST_SYNC, 0, 28, 39};
894 CheckSeekMode(fileTest3);
895 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_CLOSEST_SYNC, 0, 30, 19};
896 CheckSeekMode(fileTest4);
897 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_CLOSEST_SYNC, 0, 29, 44};
898 CheckSeekMode(fileTest5);
899 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_CLOSEST_SYNC, 0, 30, 42};
900 CheckSeekMode(fileTest6);
901 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_CLOSEST_SYNC, 0, 26, 14};
902 CheckSeekMode(fileTest7);
903 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_CLOSEST_SYNC, 0, 12, 21};
904 CheckSeekMode(fileTest8);
905 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_CLOSEST_SYNC, 0, 30, 47};
906 CheckSeekMode(fileTest9);
907 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_CLOSEST_SYNC, 0, 30, 39};
908 CheckSeekMode(fileTest10);
909 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_CLOSEST_SYNC, 0, 30, 43};
910 CheckSeekMode(fileTest11);
911 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_CLOSEST_SYNC, 0, 30, 17};
912 CheckSeekMode(fileTest12);
913 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_CLOSEST_SYNC, 0, 29, 45};
914 CheckSeekMode(fileTest13);
915 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_CLOSEST_SYNC, 0, 30, 42};
916 CheckSeekMode(fileTest14);
917 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_CLOSEST_SYNC, 0, 24, 14};
918 CheckSeekMode(fileTest15);
919 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_CLOSEST_SYNC, 0, 30, 44};
920 CheckSeekMode(fileTest16);
921 }
922
923 /**
924 * @tc.number : DEMUXER_AVI_FUNC_3500
925 * @tc.name : seek to the end time, previous mode
926 * @tc.desc : function test
927 */
928 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3500, TestSize.Level1)
929 {
930 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_PREVIOUS_SYNC, 966667, 1, 1};
931 CheckSeekMode(fileTest1);
932 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_PREVIOUS_SYNC, 983333, 1, 1};
933 CheckSeekMode(fileTest2);
934 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_PREVIOUS_SYNC, 966667, 1, 2};
935 CheckSeekMode(fileTest3);
936 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_PREVIOUS_SYNC, 1301300, 6, 4};
937 CheckSeekMode(fileTest4);
938 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_PREVIOUS_SYNC, 966667, 29, 44};
939 CheckSeekMode(fileTest5);
940 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_PREVIOUS_SYNC, 966667, 30, 42};
941 CheckSeekMode(fileTest6);
942 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_PREVIOUS_SYNC, 966667, 26, 14};
943 CheckSeekMode(fileTest7);
944 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_PREVIOUS_SYNC, 400000, 12, 21};
945 CheckSeekMode(fileTest8);
946 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_PREVIOUS_SYNC, 966667, 6, 1};
947 CheckSeekMode(fileTest9);
948 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_PREVIOUS_SYNC, 966667, 6, 8};
949 CheckSeekMode(fileTest10);
950 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_PREVIOUS_SYNC, 1000000, 6, 8};
951 CheckSeekMode(fileTest11);
952 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_PREVIOUS_SYNC, 1366667, 6, 1};
953 CheckSeekMode(fileTest12);
954 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_PREVIOUS_SYNC, 1000000, 5, 8};
955 CheckSeekMode(fileTest13);
956 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_PREVIOUS_SYNC, 983333, 6, 8};
957 CheckSeekMode(fileTest14);
958 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_PREVIOUS_SYNC, 966667, 12, 6};
959 CheckSeekMode(fileTest15);
960 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_PREVIOUS_SYNC, 983333, 6, 9};
961 CheckSeekMode(fileTest16);
962 }
963
964 /**
965 * @tc.number : DEMUXER_AVI_FUNC_3600
966 * @tc.name : seek to the end time, next mode
967 * @tc.desc : function test
968 */
969 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3600, TestSize.Level1)
970 {
971 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_NEXT_SYNC, 966667, 1, 1};
972 CheckSeekMode(fileTest1);
973 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_NEXT_SYNC, 983333, 1, 1};
974 CheckSeekMode(fileTest2);
975 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_NEXT_SYNC, 966667, 1, 2};
976 CheckSeekMode(fileTest3);
977 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_NEXT_SYNC, 1301300, 0, 0};
978 CheckSeekModefromEnd(fileTest4);
979 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_NEXT_SYNC, 966667, 0, 0};
980 CheckSeekModefromEnd(fileTest5);
981 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_NEXT_SYNC, 966667, 0, 0};
982 CheckSeekModefromEnd(fileTest6);
983 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_NEXT_SYNC, 966667, 0, 0};
984 CheckSeekModefromEnd(fileTest7);
985 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_NEXT_SYNC, 400000, 0, 0};
986 CheckSeekModefromEnd(fileTest8);
987 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_NEXT_SYNC, 966667, 0, 0};
988 CheckSeekModefromEnd(fileTest9);
989 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_NEXT_SYNC, 966667, 0, 0};
990 CheckSeekModefromEnd(fileTest10);
991 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_NEXT_SYNC, 1000000, 0, 0};
992 CheckSeekModefromEnd(fileTest11);
993 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_NEXT_SYNC, 1366667, 0, 0};
994 CheckSeekModefromEnd(fileTest12);
995 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_NEXT_SYNC, 1000000, 0, 0};
996 CheckSeekModefromEnd(fileTest13);
997 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_NEXT_SYNC, 983333, 0, 0};
998 CheckSeekModefromEnd(fileTest14);
999 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_NEXT_SYNC, 966667, 0, 0};
1000 CheckSeekModefromEnd(fileTest15);
1001 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_NEXT_SYNC, 983333, 0, 0};
1002 CheckSeekModefromEnd(fileTest16);
1003 }
1004
1005 /**
1006 * @tc.number : DEMUXER_AVI_FUNC_3700
1007 * @tc.name : seek to the end time, closest mode
1008 * @tc.desc : function test
1009 */
1010 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3700, TestSize.Level1)
1011 {
1012 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_CLOSEST_SYNC, 966667, 1, 1};
1013 CheckSeekMode(fileTest1);
1014 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_CLOSEST_SYNC, 983333, 1, 1};
1015 CheckSeekMode(fileTest2);
1016 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_CLOSEST_SYNC, 966667, 1, 2};
1017 CheckSeekMode(fileTest3);
1018 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_CLOSEST_SYNC, 1301300, 6, 4};
1019 CheckSeekMode(fileTest4);
1020 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_CLOSEST_SYNC, 966667, 29, 44};
1021 CheckSeekMode(fileTest5);
1022 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_CLOSEST_SYNC, 966667, 30, 42};
1023 CheckSeekMode(fileTest6);
1024 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_CLOSEST_SYNC, 966667, 26, 14};
1025 CheckSeekMode(fileTest7);
1026 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_CLOSEST_SYNC, 400000, 12, 21};
1027 CheckSeekMode(fileTest8);
1028 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_CLOSEST_SYNC, 966667, 6, 1};
1029 CheckSeekMode(fileTest9);
1030 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_CLOSEST_SYNC, 966667, 6, 8};
1031 CheckSeekMode(fileTest10);
1032 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_CLOSEST_SYNC, 1008000, 6, 8};
1033 CheckSeekMode(fileTest11);
1034 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_CLOSEST_SYNC, 1366667, 6, 1};
1035 CheckSeekMode(fileTest12);
1036 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_CLOSEST_SYNC, 1000000, 5, 8};
1037 CheckSeekMode(fileTest13);
1038 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_CLOSEST_SYNC, 983333, 6, 8};
1039 CheckSeekMode(fileTest14);
1040 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_CLOSEST_SYNC, 966667, 12, 6};
1041 CheckSeekMode(fileTest15);
1042 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_CLOSEST_SYNC, 983333, 6, 9};
1043 CheckSeekMode(fileTest16);
1044 }
1045
1046 /**
1047 * @tc.number : DEMUXER_AVI_FUNC_3800
1048 * @tc.name : seek to the middle time, previous mode
1049 * @tc.desc : function test
1050 */
1051 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3800, TestSize.Level1)
1052 {
1053 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_PREVIOUS_SYNC, 500000, 15, 1};
1054 CheckSeekMode(fileTest1);
1055 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_PREVIOUS_SYNC, 500000, 16, 20};
1056 CheckSeekMode(fileTest2);
1057 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_PREVIOUS_SYNC, 500000, 15, 20};
1058 CheckSeekMode(fileTest3);
1059 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_PREVIOUS_SYNC, 600000, 30, 19};
1060 CheckSeekMode(fileTest4);
1061 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_PREVIOUS_SYNC, 500000, 29, 44};
1062 CheckSeekMode(fileTest5);
1063 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_PREVIOUS_SYNC, 500000, 30, 42};
1064 CheckSeekMode(fileTest6);
1065 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_PREVIOUS_SYNC, 500000, 26, 14};
1066 CheckSeekMode(fileTest7);
1067 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_PREVIOUS_SYNC, 200000, 12, 21};
1068 CheckSeekMode(fileTest8);
1069 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_PREVIOUS_SYNC, 500000, 18, 1};
1070 CheckSeekMode(fileTest9);
1071 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_PREVIOUS_SYNC, 500000, 18, 24};
1072 CheckSeekMode(fileTest10);
1073 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_PREVIOUS_SYNC, 500000, 18, 25};
1074 CheckSeekMode(fileTest11);
1075 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_PREVIOUS_SYNC, 600000, 30, 17};
1076 CheckSeekMode(fileTest12);
1077 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_PREVIOUS_SYNC, 500000, 17, 25};
1078 CheckSeekMode(fileTest13);
1079 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_PREVIOUS_SYNC, 500000, 18, 25};
1080 CheckSeekMode(fileTest14);
1081 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_PREVIOUS_SYNC, 500000, 24, 14};
1082 CheckSeekMode(fileTest15);
1083 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_PREVIOUS_SYNC, 500000, 18, 27};
1084 CheckSeekMode(fileTest16);
1085 }
1086
1087 /**
1088 * @tc.number : DEMUXER_AVI_FUNC_3900
1089 * @tc.name : seek to the middle time, next mode
1090 * @tc.desc : function testZHE
1091 */
1092 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_3900, TestSize.Level1)
1093 {
1094 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_NEXT_SYNC, 500000, 15, 1};
1095 CheckSeekMode(fileTest1);
1096 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_NEXT_SYNC, 500000, 15, 19};
1097 CheckSeekMode(fileTest2);
1098 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_NEXT_SYNC, 500000, 15, 20};
1099 CheckSeekMode(fileTest3);
1100 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_NEXT_SYNC, 600000, 18, 9};
1101 CheckSeekMode(fileTest4);
1102 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_NEXT_SYNC, 500000, 0, 0};
1103 CheckSeekModefromEnd(fileTest5);
1104 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_NEXT_SYNC, 500000, 0, 0};
1105 CheckSeekModefromEnd(fileTest6);
1106 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_NEXT_SYNC, 500000, 0, 0};
1107 CheckSeekModefromEnd(fileTest7);
1108 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_NEXT_SYNC, 200000, 0, 0};
1109 CheckSeekModefromEnd(fileTest8);
1110 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_NEXT_SYNC, 500000, 6, 1};
1111 CheckSeekMode(fileTest9);
1112 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_NEXT_SYNC, 500000, 6, 8};
1113 CheckSeekMode(fileTest10);
1114 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_NEXT_SYNC, 500000, 6, 8};
1115 CheckSeekMode(fileTest11);
1116 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_NEXT_SYNC, 600000, 18, 6};
1117 CheckSeekMode(fileTest12);
1118 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_NEXT_SYNC, 500000, 5, 8};
1119 CheckSeekMode(fileTest13);
1120 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_NEXT_SYNC, 500000, 6, 8};
1121 CheckSeekMode(fileTest14);
1122 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_NEXT_SYNC, 500000, 12, 6};
1123 CheckSeekMode(fileTest15);
1124 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_NEXT_SYNC, 500000, 6, 9};
1125 CheckSeekMode(fileTest16);
1126 }
1127
1128 /**
1129 * @tc.number : DEMUXER_AVI_FUNC_4000
1130 * @tc.name : seek to the middle time, closest mode
1131 * @tc.desc : function test
1132 */
1133 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4000, TestSize.Level1)
1134 {
1135 seekInfo fileTest1{INP_DIR_1, SEEK_MODE_CLOSEST_SYNC, 500000, 15, 1};
1136 CheckSeekMode(fileTest1);
1137 seekInfo fileTest2{INP_DIR_2, SEEK_MODE_CLOSEST_SYNC, 500000, 16, 20};
1138 CheckSeekMode(fileTest2);
1139 seekInfo fileTest3{INP_DIR_3, SEEK_MODE_CLOSEST_SYNC, 500000, 15, 20};
1140 CheckSeekMode(fileTest3);
1141 seekInfo fileTest4{INP_DIR_4, SEEK_MODE_CLOSEST_SYNC, 600000, 18, 9};
1142 CheckSeekMode(fileTest4);
1143 seekInfo fileTest5{INP_DIR_5, SEEK_MODE_CLOSEST_SYNC, 500000, 29, 44};
1144 CheckSeekMode(fileTest5);
1145 seekInfo fileTest6{INP_DIR_6, SEEK_MODE_CLOSEST_SYNC, 500000, 30, 42};
1146 CheckSeekMode(fileTest6);
1147 seekInfo fileTest7{INP_DIR_7, SEEK_MODE_CLOSEST_SYNC, 500000, 26, 14};
1148 CheckSeekMode(fileTest7);
1149 seekInfo fileTest8{INP_DIR_8, SEEK_MODE_CLOSEST_SYNC, 200000, 12, 21};
1150 CheckSeekMode(fileTest8);
1151 seekInfo fileTest9{INP_DIR_9, SEEK_MODE_CLOSEST_SYNC, 500000, 18, 1};
1152 CheckSeekMode(fileTest9);
1153 seekInfo fileTest10{INP_DIR_10, SEEK_MODE_CLOSEST_SYNC, 500000, 18, 24};
1154 CheckSeekMode(fileTest10);
1155 seekInfo fileTest11{INP_DIR_11, SEEK_MODE_CLOSEST_SYNC, 500000, 18, 25};
1156 CheckSeekMode(fileTest11);
1157 seekInfo fileTest12{INP_DIR_12, SEEK_MODE_CLOSEST_SYNC, 600000, 18, 6};
1158 CheckSeekMode(fileTest12);
1159 seekInfo fileTest13{INP_DIR_13, SEEK_MODE_CLOSEST_SYNC, 500000, 17, 25};
1160 CheckSeekMode(fileTest13);
1161 seekInfo fileTest14{INP_DIR_14, SEEK_MODE_CLOSEST_SYNC, 500000, 18, 25};
1162 CheckSeekMode(fileTest14);
1163 seekInfo fileTest15{INP_DIR_15, SEEK_MODE_CLOSEST_SYNC, 500000, 12, 6};
1164 CheckSeekMode(fileTest15);
1165 seekInfo fileTest16{INP_DIR_16, SEEK_MODE_CLOSEST_SYNC, 500000, 18, 27};
1166 CheckSeekMode(fileTest16);
1167 }
1168
1169 /**
1170 * @tc.number : DEMUXER_AVI_FUNC_4100
1171 * @tc.name : demuxer damaged avi video file
1172 * @tc.desc : function test
1173 */
1174 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4100, TestSize.Level2)
1175 {
1176 int tarckType = 0;
1177 bool readingFailed = false;
1178 OH_AVCodecBufferAttr attr;
1179 bool videoIsEnd = false;
1180 const char *file = "/data/test/media/error.avi";
1181 g_fd = open(file, O_RDONLY);
1182 int64_t size = GetFileSize(file);
1183 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1184 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1185 ASSERT_NE(source, nullptr);
1186 demuxer = OH_AVDemuxer_CreateWithSource(source);
1187 ASSERT_NE(demuxer, nullptr);
1188 sourceFormat = OH_AVSource_GetSourceFormat(source);
1189 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
1190 ASSERT_EQ(g_trackCount, TWO);
1191 for (int32_t index = 0; index < g_trackCount; index++) {
1192 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index));
1193 }
1194 bool audioIsEnd = false;
1195 while (!audioIsEnd || !videoIsEnd) {
1196 for (int32_t index = 0; index < g_trackCount; index++) {
1197 trackFormat = OH_AVSource_GetTrackFormat(source, index);
1198 ASSERT_NE(trackFormat, nullptr);
1199 ASSERT_TRUE(OH_AVFormat_GetIntValue(trackFormat, OH_MD_KEY_TRACK_TYPE, &tarckType));
1200 OH_AVFormat_Destroy(trackFormat);
1201 trackFormat = nullptr;
1202 if ((audioIsEnd && (tarckType == MEDIA_TYPE_AUD)) || (videoIsEnd && (tarckType == MEDIA_TYPE_VID))) {
1203 continue;
1204 }
1205 int readResult = OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr);
1206 if (readResult != AV_ERR_OK) {
1207 cerr << "Failed to read sample for track " << index << ", error code: " << ret << endl;
1208 readingFailed = true;
1209 break;
1210 }
1211 }
1212 if (readingFailed) {
1213 break;
1214 }
1215 }
1216 close(g_fd);
1217 }
1218
1219 /**
1220 * @tc.number : DEMUXER_AVI_FUNC_4200
1221 * @tc.name : demux avi, zero track
1222 * @tc.desc : function test
1223 */
1224 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4200, TestSize.Level2)
1225 {
1226 const char *file = "/data/test/media/zero_track.avi";
1227 g_fd = open(file, O_RDONLY);
1228 int64_t size = GetFileSize(file);
1229 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1230 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1231 ASSERT_NE(source, nullptr);
1232 demuxer = OH_AVDemuxer_CreateWithSource(source);
1233 ASSERT_NE(demuxer, nullptr);
1234
1235 sourceFormat = OH_AVSource_GetSourceFormat(source);
1236 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
1237 ASSERT_EQ(g_trackCount, 0);
1238
1239 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_SelectTrackByID(demuxer, 0));
1240 close(g_fd);
1241 }
1242
1243 /**
1244 * @tc.number : DEMUXER_AVI_FUNC_4300
1245 * @tc.name : seek to a invalid time, closest mode
1246 * @tc.desc : function test
1247 */
1248 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4300, TestSize.Level2)
1249 {
1250 const char *file = INP_DIR_12;
1251 srand(time(nullptr));
1252 g_fd = open(file, O_RDONLY);
1253 int64_t size = GetFileSize(file);
1254 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1255 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1256 ASSERT_NE(source, nullptr);
1257
1258 demuxer = OH_AVDemuxer_CreateWithSource(source);
1259 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0));
1260
1261 ASSERT_NE(demuxer, nullptr);
1262 int64_t invalidPts = 12000 * 16666;
1263 ret = OH_AVDemuxer_SeekToTime(demuxer, invalidPts, SEEK_MODE_CLOSEST_SYNC);
1264 ASSERT_NE(ret, AV_ERR_OK);
1265 close(g_fd);
1266 }
1267
1268 /**
1269 * @tc.number : DEMUXER_AVI_FUNC_4400
1270 * @tc.name : remove track before add track
1271 * @tc.desc : function test
1272 */
1273 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4400, TestSize.Level2)
1274 {
1275 const char *file = INP_DIR_7;
1276 srand(time(nullptr));
1277 g_fd = open(file, O_RDONLY);
1278 int64_t size = GetFileSize(file);
1279 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1280 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1281 ASSERT_NE(source, nullptr);
1282 demuxer = OH_AVDemuxer_CreateWithSource(source);
1283 ASSERT_NE(demuxer, nullptr);
1284 ret = OH_AVDemuxer_UnselectTrackByID(demuxer, 0);
1285 ASSERT_EQ(ret, AV_ERR_OK);
1286 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
1287 ASSERT_EQ(ret, AV_ERR_OK);
1288 close(g_fd);
1289 }
1290
1291 /**
1292 * @tc.number : DEMUXER_AVI_FUNC_4500
1293 * @tc.name : remove all tracks before demux finish
1294 * @tc.desc : function test
1295 */
1296 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4500, TestSize.Level2)
1297 {
1298 OH_AVCodecBufferAttr attr;
1299 const char *file = INP_DIR_13;
1300 bool isEnd = false;
1301 int count = 0;
1302 g_fd = open(file, O_RDONLY);
1303 int64_t size = GetFileSize(file);
1304 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1305 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1306 ASSERT_NE(source, nullptr);
1307 demuxer = OH_AVDemuxer_CreateWithSource(source);
1308 ASSERT_NE(demuxer, nullptr);
1309 sourceFormat = OH_AVSource_GetSourceFormat(source);
1310 ASSERT_TRUE(OH_AVFormat_GetIntValue(sourceFormat, OH_MD_KEY_TRACK_COUNT, &g_trackCount));
1311 ASSERT_EQ(g_trackCount, TWO);
1312 for (int32_t index = 0; index < g_trackCount; index++) {
1313 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, index));
1314 }
1315 srand(time(nullptr));
1316 int pos = rand() % 250;
1317 cout << " pos= " << pos << endl;
1318 while (!isEnd) {
1319 for (int32_t index = 0; index < g_trackCount; index++) {
1320 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr));
1321 if (count == pos) {
1322 cout << count << " count == pos!!!!!!!!!" << endl;
1323 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_UnselectTrackByID(demuxer, 0));
1324 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_UnselectTrackByID(demuxer, 1));
1325 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, OH_AVDemuxer_ReadSample(demuxer, index, memory, &attr));
1326 isEnd = true;
1327 break;
1328 }
1329 if (attr.flags & OH_AVCodecBufferFlags::AVCODEC_BUFFER_FLAGS_EOS) {
1330 isEnd = true;
1331 cout << "is end !!!!!!!!!!!!!!!" << endl;
1332 }
1333 if (index == MEDIA_TYPE_AUD) {
1334 count++;
1335 }
1336 }
1337 }
1338 close(g_fd);
1339 }
1340
1341 /**
1342 * @tc.number : DEMUXER_AVI_FUNC_4600
1343 * @tc.name : start demux before add track
1344 * @tc.desc : function test
1345 */
1346 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_FUNC_4600, TestSize.Level2)
1347 {
1348 uint32_t trackIndex = 0;
1349 OH_AVCodecBufferAttr attr;
1350 const char *file = INP_DIR_2;
1351 srand(time(nullptr));
1352 g_fd = open(file, O_RDONLY);
1353 int64_t size = GetFileSize(file);
1354 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1355 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1356 ASSERT_NE(source, nullptr);
1357 demuxer = OH_AVDemuxer_CreateWithSource(source);
1358 ASSERT_NE(demuxer, nullptr);
1359 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
1360 ASSERT_EQ(ret, AV_ERR_OPERATE_NOT_PERMIT);
1361 close(g_fd);
1362 }
1363
1364 /**
1365 * @tc.number : DEMUXER_AVI_ILLEGAL_PARA_0100
1366 * @tc.name : input invalid avi g_fd file
1367 * @tc.desc : function test
1368 */
1369 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_ILLEGAL_PARA_0100, TestSize.Level2)
1370 {
1371 const char *file = "/data/test/media/invalid.avi";
1372 g_fd = open(file, O_RDONLY);
1373 int64_t size = GetFileSize(file);
1374 cout << file << "----------------------" << g_fd << "---------" << size << endl;
1375 source = OH_AVSource_CreateWithFD(g_fd, 0, size);
1376 ASSERT_EQ(source, nullptr);
1377 }
1378
1379 /**
1380 * @tc.number : DEMUXER_AVI_ILLEGAL_PARA_0200
1381 * @tc.name : input invalid avi uri file
1382 * @tc.desc : function test
1383 */
1384 HWTEST_F(DemuxerAviFuncNdkTest, DEMUXER_AVI_ILLEGAL_PARA_0200, TestSize.Level2)
1385 {
1386 const char *uri = "http://192.168.3.11:8080/share/invalid.avi";
1387 source = OH_AVSource_CreateWithURI(const_cast<char *>(uri));
1388 ASSERT_EQ(source, nullptr);
1389 }
1390