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    : DEMUXER_ILLEGAL_PARA_0100
104 * @tc.name      : OH_AVSource_CreateWithURI para error
105 * @tc.desc      : api test
106 */
107HWTEST_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 */
118HWTEST_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 */
130HWTEST_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 */
142HWTEST_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 */
154HWTEST_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 */
164HWTEST_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 */
175HWTEST_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 */
186HWTEST_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 */
199HWTEST_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 */
210HWTEST_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 */
221HWTEST_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 */
231HWTEST_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 */
241HWTEST_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 */
254HWTEST_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 */
264HWTEST_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 */
278HWTEST_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 */
290HWTEST_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 */
306HWTEST_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 */
327HWTEST_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 */
347HWTEST_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 */
363HWTEST_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 */
374HWTEST_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 */
389HWTEST_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 */
409HWTEST_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 */
428HWTEST_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 */
443HWTEST_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 */
458HWTEST_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 */
468HWTEST_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 */
479HWTEST_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 */
489HWTEST_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 */
516HWTEST_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 */
529HWTEST_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 */
545HWTEST_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 */
562HWTEST_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 */
580HWTEST_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 */
599HWTEST_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 */
620HWTEST_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 */
641HWTEST_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 */
662HWTEST_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 */
675HWTEST_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 */
688HWTEST_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