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