1 /*
2 * Copyright (C) 2023 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_avbuffer.h"
23
24 #include <iostream>
25 #include <cstdio>
26 #include <string>
27 #include <fcntl.h>
28
29 namespace OHOS {
30 namespace Media {
31 class DemuxerApiNdkTest : public testing::Test {
32 public:
33 // SetUpTestCase: Called before all test cases
34 static void SetUpTestCase(void);
35 // TearDownTestCase: Called after all test case
36 static void TearDownTestCase(void);
37 // SetUp: Called before each test cases
38 void SetUp(void);
39 // TearDown: Called after each test cases
40 void TearDown(void);
41
42 public:
43 int fd1;
44 int64_t size;
45 };
46 static int32_t g_width = 3840;
47 static int32_t g_height = 2160;
48 static OH_AVMemory *memory = nullptr;
49 static OH_AVBuffer *buffer = nullptr;
50 static OH_AVSource *source = nullptr;
51 static OH_AVDemuxer *demuxer = nullptr;
52 const char *g_file1 = "/data/test/media/01_video_audio.mp4";
53 const char *g_file2 = "/data/test/media/avcc_10sec.mp4";
54
SetUpTestCase()55 void DemuxerApiNdkTest::SetUpTestCase() {}
TearDownTestCase()56 void DemuxerApiNdkTest::TearDownTestCase() {}
57
SetUp()58 void DemuxerApiNdkTest::SetUp()
59 {
60 memory = OH_AVMemory_Create(g_width * g_height);
61 buffer = OH_AVBuffer_Create(g_width * g_height);
62 fd1 = open(g_file1, O_RDONLY);
63
64 struct stat fileStatus {};
65 if (stat(g_file1, &fileStatus) == 0) {
66 size = static_cast<int64_t>(fileStatus.st_size);
67 }
68
69 std::cout << fd1 << "----------" << g_file1 << "=====" << size << std::endl;
70 }
71
TearDown()72 void DemuxerApiNdkTest::TearDown()
73 {
74 close(fd1);
75 fd1 = 0;
76 if (memory != nullptr) {
77 OH_AVMemory_Destroy(memory);
78 memory = nullptr;
79 }
80 if (buffer != nullptr) {
81 OH_AVBuffer_Destroy(buffer);
82 buffer = nullptr;
83 }
84 if (source != nullptr) {
85 OH_AVSource_Destroy(source);
86 source = nullptr;
87 }
88 if (demuxer != nullptr) {
89 OH_AVDemuxer_Destroy(demuxer);
90 demuxer = nullptr;
91 }
92 }
93 } // namespace Media
94 } // namespace OHOS
95
96 namespace {
97 using namespace std;
98 using namespace OHOS;
99 using namespace OHOS::Media;
100 using namespace testing::ext;
101
102 /**
103 * @tc.number : DEMUXER_ILLEGAL_PARA_0100
104 * @tc.name : OH_AVSource_CreateWithURI para error
105 * @tc.desc : api test
106 */
107 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0100, TestSize.Level2)
108 {
109 source = OH_AVSource_CreateWithURI(nullptr);
110 ASSERT_EQ(nullptr, source);
111 }
112
113 /**
114 * @tc.number : DEMUXER_ILLEGAL_PARA_0200
115 * @tc.name : OH_AVSource_CreateWithFD para error
116 * @tc.desc : api test
117 */
118 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0200, TestSize.Level2)
119 {
120 // fd must bigger than 2
121 source = OH_AVSource_CreateWithFD(2, 0, 0);
122 ASSERT_EQ(nullptr, source);
123 }
124
125 /**
126 * @tc.number : DEMUXER_ILLEGAL_PARA_0700
127 * @tc.name : OH_AVSource_CreateWithFD para error
128 * @tc.desc : api test
129 */
130 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0700, TestSize.Level2)
131 {
132 // fd must bigger than 2
133 source = OH_AVSource_CreateWithFD(3, 0, -1);
134 ASSERT_EQ(nullptr, source);
135 }
136
137 /**
138 * @tc.number : DEMUXER_ILLEGAL_PARA_0800
139 * @tc.name : OH_AVSource_CreateWithFD para error
140 * @tc.desc : api test
141 */
142 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0800, TestSize.Level2)
143 {
144 // fd must bigger than 2
145 source = OH_AVSource_CreateWithFD(3, -1, 1);
146 ASSERT_EQ(nullptr, source);
147 }
148
149 /**
150 * @tc.number : DEMUXER_ILLEGAL_PARA_0300
151 * @tc.name : OH_AVSource_Destroy para error
152 * @tc.desc : api test
153 */
154 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0300, TestSize.Level2)
155 {
156 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVSource_Destroy(nullptr));
157 }
158
159 /**
160 * @tc.number : DEMUXER_ILLEGAL_PARA_0400
161 * @tc.name : OH_AVSource_GetSourceFormat para error
162 * @tc.desc : api test
163 */
164 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0400, TestSize.Level2)
165 {
166 OH_AVFormat *format = OH_AVSource_GetSourceFormat(nullptr);
167 ASSERT_EQ(nullptr, format);
168 }
169
170 /**
171 * @tc.number : DEMUXER_ILLEGAL_PARA_0500
172 * @tc.name : OH_AVSource_GetTrackFormat para error
173 * @tc.desc : api test
174 */
175 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0500, TestSize.Level2)
176 {
177 OH_AVFormat *format = OH_AVSource_GetTrackFormat(nullptr, 0);
178 ASSERT_EQ(nullptr, format);
179 }
180
181 /**
182 * @tc.number : DEMUXER_ILLEGAL_PARA_0600
183 * @tc.name : OH_AVSource_GetSourceFormat para error
184 * @tc.desc : api test
185 */
186 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0600, TestSize.Level2)
187 {
188 source = OH_AVSource_CreateWithFD(fd1, 0, size);
189 ASSERT_NE(nullptr, source);
190 OH_AVFormat *format = OH_AVSource_GetTrackFormat(source, -1);
191 ASSERT_EQ(nullptr, format);
192 }
193
194 /**
195 * @tc.number : DEMUXER_ILLEGAL_PARA_2300
196 * @tc.name : OH_AVSource_CreateWithFD para error
197 * @tc.desc : api test
198 */
199 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2300, TestSize.Level2)
200 {
201 source = OH_AVSource_CreateWithFD(fd1, 0, 0);
202 ASSERT_EQ(nullptr, source);
203 }
204
205 /**
206 * @tc.number : DEMUXER_ILLEGAL_PARA_0900
207 * @tc.name : OH_AVDemuxer_CreateWithSource para error
208 * @tc.desc : api test
209 */
210 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0900, TestSize.Level2)
211 {
212 demuxer = OH_AVDemuxer_CreateWithSource(nullptr);
213 ASSERT_EQ(nullptr, demuxer);
214 }
215
216 /**
217 * @tc.number : DEMUXER_ILLEGAL_PARA_1000
218 * @tc.name : OH_AVDemuxer_Destroy para error
219 * @tc.desc : api test
220 */
221 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1000, TestSize.Level2)
222 {
223 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_Destroy(nullptr));
224 }
225
226 /**
227 * @tc.number : DEMUXER_ILLEGAL_PARA_1100
228 * @tc.name : OH_AVDemuxer_SelectTrackByID para error
229 * @tc.desc : api test
230 */
231 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1100, TestSize.Level2)
232 {
233 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_SelectTrackByID(nullptr, 0));
234 }
235
236 /**
237 * @tc.number : DEMUXER_ILLEGAL_PARA_1200
238 * @tc.name : OH_AVDemuxer_SelectTrackByID para error
239 * @tc.desc : api test
240 */
241 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1200, TestSize.Level2)
242 {
243 source = OH_AVSource_CreateWithFD(fd1, 0, size);
244 ASSERT_NE(nullptr, source);
245 demuxer = OH_AVDemuxer_CreateWithSource(source);
246 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_SelectTrackByID(demuxer, -1));
247 }
248
249 /**
250 * @tc.number : DEMUXER_ILLEGAL_PARA_1300
251 * @tc.name : OH_AVDemuxer_UnselectTrackByID para error
252 * @tc.desc : api test
253 */
254 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1300, TestSize.Level2)
255 {
256 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_UnselectTrackByID(nullptr, 0));
257 }
258
259 /**
260 * @tc.number : DEMUXER_ILLEGAL_PARA_1400
261 * @tc.name : OH_AVDemuxer_UnselectTrackByID para error
262 * @tc.desc : api test
263 */
264 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1400, TestSize.Level2)
265 {
266 source = OH_AVSource_CreateWithFD(fd1, 0, size);
267 ASSERT_NE(nullptr, source);
268 demuxer = OH_AVDemuxer_CreateWithSource(source);
269 ASSERT_NE(nullptr, demuxer);
270 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_UnselectTrackByID(demuxer, -1)); // unselect ok
271 }
272
273 /**
274 * @tc.number : DEMUXER_ILLEGAL_PARA_1500
275 * @tc.name : OH_AVDemuxer_ReadSample para error
276 * @tc.desc : api test
277 */
278 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1500, TestSize.Level2)
279 {
280 uint32_t trackIndex = 0;
281 OH_AVCodecBufferAttr bufferAttr;
282 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_ReadSample(nullptr, trackIndex, memory, &bufferAttr));
283 }
284
285 /**
286 * @tc.number : DEMUXER_ILLEGAL_PARA_1600
287 * @tc.name : OH_AVDemuxer_ReadSample para error
288 * @tc.desc : api test
289 */
290 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1600, TestSize.Level2)
291 {
292 uint32_t trackIndex = -1;
293 OH_AVCodecBufferAttr bufferAttr;
294 source = OH_AVSource_CreateWithFD(fd1, 0, size);
295 ASSERT_NE(nullptr, source);
296 demuxer = OH_AVDemuxer_CreateWithSource(source);
297 ASSERT_NE(nullptr, demuxer);
298 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &bufferAttr));
299 }
300
301 /**
302 * @tc.number : DEMUXER_ILLEGAL_PARA_1700
303 * @tc.name : OH_AVDemuxer_ReadSample para error
304 * @tc.desc : api test
305 */
306 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1700, TestSize.Level2)
307 {
308 uint32_t trackIndex = 0;
309 OH_AVMemory *memory1 = OH_AVMemory_Create(2);
310 OH_AVCodecBufferAttr bufferAttr;
311 source = OH_AVSource_CreateWithFD(fd1, 0, size);
312 ASSERT_NE(nullptr, source);
313 demuxer = OH_AVDemuxer_CreateWithSource(source);
314 ASSERT_NE(nullptr, demuxer);
315 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0));
316 ASSERT_EQ(AV_ERR_NO_MEMORY, OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory1, &bufferAttr));
317
318 OH_AVMemory_Destroy(memory1);
319 memory1 = nullptr;
320 }
321
322 /**
323 * @tc.number : DEMUXER_ILLEGAL_PARA_8600
324 * @tc.name : OH_AVDemuxer_ReadSample para error
325 * @tc.desc : api test
326 */
327 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2400, TestSize.Level2)
328 {
329 uint32_t trackIndex = 0;
330 OH_AVMemory *memory1 = OH_AVMemory_Create(2);
331 OH_AVCodecBufferAttr bufferAttr;
332 source = OH_AVSource_CreateWithFD(fd1, 0, size);
333 ASSERT_NE(nullptr, source);
334 demuxer = OH_AVDemuxer_CreateWithSource(source);
335 ASSERT_NE(nullptr, demuxer);
336 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory1, &bufferAttr));
337
338 OH_AVMemory_Destroy(memory1);
339 memory1 = nullptr;
340 }
341
342 /**
343 * @tc.number : DEMUXER_ILLEGAL_PARA_1700
344 * @tc.name : OH_AVDemuxer_ReadSample para error
345 * @tc.desc : api test
346 */
347 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2500, TestSize.Level2)
348 {
349 uint32_t trackIndex = 0;
350 OH_AVCodecBufferAttr bufferAttr;
351 source = OH_AVSource_CreateWithFD(fd1, 0, size);
352 ASSERT_NE(nullptr, source);
353 demuxer = OH_AVDemuxer_CreateWithSource(source);
354 ASSERT_NE(nullptr, demuxer);
355 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_ReadSample(demuxer, trackIndex, nullptr, &bufferAttr));
356 }
357
358 /**
359 * @tc.number : DEMUXER_ILLEGAL_PARA_2600
360 * @tc.name : OH_AVDemuxer_ReadSampleBuffer para error, input null demuxer
361 * @tc.desc : api test
362 */
363 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2600, TestSize.Level2)
364 {
365 uint32_t trackIndex = 0;
366 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_ReadSampleBuffer(nullptr, trackIndex, buffer));
367 }
368
369 /**
370 * @tc.number : DEMUXER_ILLEGAL_PARA_2700
371 * @tc.name : OH_AVDemuxer_ReadSampleBuffer para error, input illegal trackIndex
372 * @tc.desc : api test
373 */
374 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2700, TestSize.Level2)
375 {
376 uint32_t trackIndex = -1;
377 source = OH_AVSource_CreateWithFD(fd1, 0, size);
378 ASSERT_NE(nullptr, source);
379 demuxer = OH_AVDemuxer_CreateWithSource(source);
380 ASSERT_NE(nullptr, demuxer);
381 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, OH_AVDemuxer_ReadSampleBuffer(demuxer, trackIndex, buffer));
382 }
383
384 /**
385 * @tc.number : DEMUXER_ILLEGAL_PARA_2800
386 * @tc.name : OH_AVDemuxer_ReadSampleBuffer para error, input buffer is not enough
387 * @tc.desc : api test
388 */
389 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2800, TestSize.Level2)
390 {
391 uint32_t trackIndex = 0;
392 OH_AVBuffer *buffer1 = OH_AVBuffer_Create(2);
393 source = OH_AVSource_CreateWithFD(fd1, 0, size);
394 ASSERT_NE(nullptr, source);
395 demuxer = OH_AVDemuxer_CreateWithSource(source);
396 ASSERT_NE(nullptr, demuxer);
397 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_SelectTrackByID(demuxer, 0));
398 ASSERT_EQ(AV_ERR_NO_MEMORY, OH_AVDemuxer_ReadSampleBuffer(demuxer, trackIndex, buffer1));
399
400 OH_AVBuffer_Destroy(buffer1);
401 buffer1 = nullptr;
402 }
403
404 /**
405 * @tc.number : DEMUXER_ILLEGAL_PARA_2900
406 * @tc.name : OH_AVDemuxer_ReadSampleBuffer para error, read before select
407 * @tc.desc : api test
408 */
409 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2900, TestSize.Level2)
410 {
411 uint32_t trackIndex = 0;
412 OH_AVBuffer *buffer1 = OH_AVBuffer_Create(2);
413 source = OH_AVSource_CreateWithFD(fd1, 0, size);
414 ASSERT_NE(nullptr, source);
415 demuxer = OH_AVDemuxer_CreateWithSource(source);
416 ASSERT_NE(nullptr, demuxer);
417 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, OH_AVDemuxer_ReadSampleBuffer(demuxer, trackIndex, buffer1));
418
419 OH_AVBuffer_Destroy(buffer1);
420 buffer1 = nullptr;
421 }
422
423 /**
424 * @tc.number : DEMUXER_ILLEGAL_PARA_3000
425 * @tc.name : OH_AVDemuxer_ReadSampleBuffer para error, input null buffer
426 * @tc.desc : api test
427 */
428 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_3000, TestSize.Level2)
429 {
430 uint32_t trackIndex = 0;
431 source = OH_AVSource_CreateWithFD(fd1, 0, size);
432 ASSERT_NE(nullptr, source);
433 demuxer = OH_AVDemuxer_CreateWithSource(source);
434 ASSERT_NE(nullptr, demuxer);
435 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_ReadSampleBuffer(demuxer, trackIndex, nullptr));
436 }
437
438 /**
439 * @tc.number : DEMUXER_ILLEGAL_PARA_1800
440 * @tc.name : OH_AVDemuxer_ReadSample para error
441 * @tc.desc : api test
442 */
443 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1800, TestSize.Level2)
444 {
445 uint32_t trackIndex = 0;
446 source = OH_AVSource_CreateWithFD(fd1, 0, size);
447 ASSERT_NE(nullptr, source);
448 demuxer = OH_AVDemuxer_CreateWithSource(source);
449 ASSERT_NE(nullptr, demuxer);
450 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, nullptr));
451 }
452
453 /**
454 * @tc.number : DEMUXER_ILLEGAL_PARA_1900
455 * @tc.name : OH_AVDemuxer_SeekToTime para error
456 * @tc.desc : api test
457 */
458 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1900, TestSize.Level2)
459 {
460 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_SeekToTime(nullptr, 1, SEEK_MODE_NEXT_SYNC));
461 }
462
463 /**
464 * @tc.number : DEMUXER_ILLEGAL_PARA_2100
465 * @tc.name : OH_AVMemory_Create para error
466 * @tc.desc : api test
467 */
468 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2100, TestSize.Level2)
469 {
470 memory = OH_AVMemory_Create(-1);
471 ASSERT_EQ(nullptr, memory);
472 }
473
474 /**
475 * @tc.number : DEMUXER_ILLEGAL_PARA_2200
476 * @tc.name : OH_AVMemory_Destroy para error
477 * @tc.desc : api test
478 */
479 HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2200, TestSize.Level2)
480 {
481 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVMemory_Destroy(nullptr));
482 }
483
484 /**
485 * @tc.number : DEMUXER_API_0200
486 * @tc.name : OH_AVSource_CreateWithFD Repeat Call
487 * @tc.desc : api test
488 */
489 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0200, TestSize.Level2)
490 {
491 OH_AVSource *source1 = OH_AVSource_CreateWithFD(fd1, 0, size);
492 ASSERT_NE(source1, nullptr);
493 int fd2 = open(g_file2, O_RDONLY);
494 int64_t size2 = 0;
495
496 struct stat fileStatus {};
497 if (stat(g_file2, &fileStatus) == 0) {
498 size2 = static_cast<int64_t>(fileStatus.st_size);
499 }
500
501 OH_AVSource *source2 = OH_AVSource_CreateWithFD(fd2, 0, size2);
502 cout << size2 << "------------------" << endl;
503 ASSERT_NE(source2, nullptr);
504 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source1));
505 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source2));
506 source1 = nullptr;
507 source2 = nullptr;
508 close(fd2);
509 }
510
511 /**
512 * @tc.number : DEMUXER_API_0300
513 * @tc.name : OH_AVSource_Destroy Repeat Call
514 * @tc.desc : api test
515 */
516 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0300, TestSize.Level2)
517 {
518 source = OH_AVSource_CreateWithFD(fd1, 0, size);
519 ASSERT_EQ(AV_ERR_OK, OH_AVSource_Destroy(source));
520 source = nullptr;
521 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVSource_Destroy(source));
522 }
523
524 /**
525 * @tc.number : DEMUXER_API_0500
526 * @tc.name : OH_AVSource_GetSourceFormat Repeat Call
527 * @tc.desc : api test
528 */
529 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0500, TestSize.Level2)
530 {
531 OH_AVFormat *format;
532 source = OH_AVSource_CreateWithFD(fd1, 0, size);
533 ASSERT_NE(source, nullptr);
534 format = OH_AVSource_GetSourceFormat(source);
535 ASSERT_NE(format, nullptr);
536 format = OH_AVSource_GetSourceFormat(source);
537 ASSERT_NE(format, nullptr);
538 }
539
540 /**
541 * @tc.number : DEMUXER_API_0700
542 * @tc.name : OH_AVSource_GetTrackFormat Repeat Call
543 * @tc.desc : api test
544 */
545 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0700, TestSize.Level2)
546 {
547 OH_AVFormat *format;
548 source = OH_AVSource_CreateWithFD(fd1, 0, size);
549 ASSERT_NE(source, nullptr);
550
551 format = OH_AVSource_GetTrackFormat(source, 0);
552 ASSERT_NE(format, nullptr);
553 format = OH_AVSource_GetTrackFormat(source, 0);
554 ASSERT_NE(format, nullptr);
555 }
556
557 /**
558 * @tc.number : DEMUXER_API_1000
559 * @tc.name : OH_AVDemuxer_Destroy Repeat Call
560 * @tc.desc : api test
561 */
562 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1000, TestSize.Level2)
563 {
564 source = OH_AVSource_CreateWithFD(fd1, 0, size);
565 ASSERT_NE(source, nullptr);
566
567 demuxer = OH_AVDemuxer_CreateWithSource(source);
568 ASSERT_NE(demuxer, nullptr);
569
570 ASSERT_EQ(AV_ERR_OK, OH_AVDemuxer_Destroy(demuxer));
571 demuxer = nullptr;
572 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVDemuxer_Destroy(demuxer));
573 }
574
575 /**
576 * @tc.number : DEMUXER_API_1100
577 * @tc.name : OH_AVDemuxer_SelectTrackByID Repeat Call
578 * @tc.desc : api test
579 */
580 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1100, TestSize.Level2)
581 {
582 OH_AVErrCode ret = AV_ERR_OK;
583 source = OH_AVSource_CreateWithFD(fd1, 0, size);
584 ASSERT_NE(source, nullptr);
585
586 demuxer = OH_AVDemuxer_CreateWithSource(source);
587 ASSERT_NE(demuxer, nullptr);
588 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
589 ASSERT_EQ(ret, AV_ERR_OK);
590 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
591 ASSERT_EQ(ret, AV_ERR_OK);
592 }
593
594 /**
595 * @tc.number : DEMUXER_API_1200
596 * @tc.name : OH_AVDemuxer_UnselectTrackByID Repeat Call
597 * @tc.desc : api test
598 */
599 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1200, TestSize.Level2)
600 {
601 OH_AVErrCode ret = AV_ERR_OK;
602 source = OH_AVSource_CreateWithFD(fd1, 0, size);
603 ASSERT_NE(source, nullptr);
604
605 demuxer = OH_AVDemuxer_CreateWithSource(source);
606 ASSERT_NE(demuxer, nullptr);
607 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
608 ASSERT_EQ(ret, AV_ERR_OK);
609 ret = OH_AVDemuxer_UnselectTrackByID(demuxer, 0);
610 ASSERT_EQ(ret, AV_ERR_OK);
611 ret = OH_AVDemuxer_UnselectTrackByID(demuxer, 0);
612 ASSERT_EQ(ret, AV_ERR_OK);
613 }
614
615 /**
616 * @tc.number : DEMUXER_API_1300
617 * @tc.name : OH_AVDemuxer_ReadSample Repeat Call
618 * @tc.desc : api test
619 */
620 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1300, TestSize.Level2)
621 {
622 OH_AVErrCode ret = AV_ERR_OK;
623 OH_AVCodecBufferAttr attr;
624 source = OH_AVSource_CreateWithFD(fd1, 0, size);
625 ASSERT_NE(source, nullptr);
626 demuxer = OH_AVDemuxer_CreateWithSource(source);
627 ASSERT_NE(demuxer, nullptr);
628 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
629 ASSERT_EQ(ret, AV_ERR_OK);
630 ret = OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr);
631 ASSERT_EQ(ret, AV_ERR_OK);
632 ret = OH_AVDemuxer_ReadSample(demuxer, 0, memory, &attr);
633 ASSERT_EQ(ret, AV_ERR_OK);
634 }
635
636 /**
637 * @tc.number : DEMUXER_API_1400
638 * @tc.name : OH_AVDemuxer_SeekToTime Repeat Call
639 * @tc.desc : api test
640 */
641 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1400, TestSize.Level2)
642 {
643 OH_AVErrCode ret = AV_ERR_OK;
644 uint32_t ms = 1000;
645 source = OH_AVSource_CreateWithFD(fd1, 0, size);
646 ASSERT_NE(source, nullptr);
647 demuxer = OH_AVDemuxer_CreateWithSource(source);
648 ASSERT_NE(demuxer, nullptr);
649 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
650 ASSERT_EQ(ret, AV_ERR_OK);
651 ret = OH_AVDemuxer_SeekToTime(demuxer, ms, SEEK_MODE_NEXT_SYNC);
652 ASSERT_EQ(ret, AV_ERR_OK);
653 ret = OH_AVDemuxer_SeekToTime(demuxer, ms, SEEK_MODE_NEXT_SYNC);
654 ASSERT_EQ(ret, AV_ERR_OK);
655 }
656
657 /**
658 * @tc.number : DEMUXER_API_1500
659 * @tc.name : OH_AVMemory_Create Repeat Call
660 * @tc.desc : api test
661 */
662 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_2300, TestSize.Level2)
663 {
664 memory = OH_AVMemory_Create(1024);
665 ASSERT_NE(nullptr, memory);
666 memory = OH_AVMemory_Create(2);
667 ASSERT_NE(nullptr, memory);
668 }
669
670 /**
671 * @tc.number : DEMUXER_ILLEGAL_PARA_2200
672 * @tc.name : OH_AVMemory_Destroy para error
673 * @tc.desc : api test
674 */
675 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_2400, TestSize.Level2)
676 {
677 memory = OH_AVMemory_Create(2);
678 ASSERT_EQ(AV_ERR_OK, OH_AVMemory_Destroy(memory));
679 memory = nullptr;
680 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_AVMemory_Destroy(memory));
681 }
682
683 /**
684 * @tc.number : DEMUXER_API_2500
685 * @tc.name : OH_AVDemuxer_ReadSampleBuffer Repeat Call
686 * @tc.desc : api test
687 */
688 HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_2500, TestSize.Level2)
689 {
690 OH_AVErrCode ret = AV_ERR_OK;
691 source = OH_AVSource_CreateWithFD(fd1, 0, size);
692 ASSERT_NE(source, nullptr);
693 demuxer = OH_AVDemuxer_CreateWithSource(source);
694 ASSERT_NE(demuxer, nullptr);
695 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
696 ASSERT_EQ(ret, AV_ERR_OK);
697 ret = OH_AVDemuxer_ReadSampleBuffer(demuxer, 0, buffer);
698 ASSERT_EQ(ret, AV_ERR_OK);
699 ret = OH_AVDemuxer_ReadSampleBuffer(demuxer, 0, buffer);
700 ASSERT_EQ(ret, AV_ERR_OK);
701 }
702 }
703