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