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