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 : OH_AVSource_CreateWithDataSource_0100
104 * @tc.name : OH_AVSource_CreateWithDataSource para error
105 * @tc.desc : api test
106 */
HWTEST_F(DemuxerApiNdkTest, OH_AVSource_CreateWithDataSource_0100, TestSize.Level2)107 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0100, TestSize.Level2)118 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0200, TestSize.Level2)129 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0700, TestSize.Level2)141 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0800, TestSize.Level2)153 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0300, TestSize.Level2)165 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0400, TestSize.Level2)175 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0500, TestSize.Level2)186 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0600, TestSize.Level2)197 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2300, TestSize.Level2)210 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_0900, TestSize.Level2)221 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1000, TestSize.Level2)232 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1100, TestSize.Level2)242 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1200, TestSize.Level2)252 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1300, TestSize.Level2)265 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1400, TestSize.Level2)275 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1500, TestSize.Level2)289 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1600, TestSize.Level2)301 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1700, TestSize.Level2)317 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2400, TestSize.Level2)338 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2500, TestSize.Level2)358 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2600, TestSize.Level2)374 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2700, TestSize.Level2)385 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2800, TestSize.Level2)400 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2900, TestSize.Level2)420 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_3000, TestSize.Level2)439 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1800, TestSize.Level2)454 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_1900, TestSize.Level2)469 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2100, TestSize.Level2)479 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_ILLEGAL_PARA_2200, TestSize.Level2)490 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0200, TestSize.Level2)500 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0300, TestSize.Level2)527 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0500, TestSize.Level2)540 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_0700, TestSize.Level2)556 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1000, TestSize.Level2)573 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1100, TestSize.Level2)591 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1200, TestSize.Level2)610 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1300, TestSize.Level2)631 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_1400, TestSize.Level2)652 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_2300, TestSize.Level2)673 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_2400, TestSize.Level2)686 HWTEST_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 */
HWTEST_F(DemuxerApiNdkTest, DEMUXER_API_2500, TestSize.Level2)699 HWTEST_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