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 "avdemuxer.h"
19 #include "avsource.h"
20 #include "meta/format.h"
21 #include "avcodec_errors.h"
22 #include "avcodec_common.h"
23 #include "buffer/avsharedmemory.h"
24 #include "buffer/avsharedmemorybase.h"
25 #include "securec.h"
26
27 #include <iostream>
28 #include <cstdio>
29 #include <string>
30 #include <fcntl.h>
31
32 using namespace std;
33 using namespace OHOS;
34 using namespace OHOS::MediaAVCodec;
35 using namespace OHOS::Media;
36 using namespace testing::ext;
37
38 namespace {
39 static int32_t g_width = 3840;
40 static int32_t g_height = 2160;
41 static std::shared_ptr<AVSource> source = nullptr;
42 static std::shared_ptr<AVDemuxer> demuxer = nullptr;
43 const char *g_file1 = "/data/test/media/01_video_audio.mp4";
44 const char *g_file2 = "/data/test/media/avcc_10sec.mp4";
45 } // namespace
46
47 namespace {
48 class DemuxerInnerApiNdkTest : public testing::Test {
49 public:
50 // SetUpTestCase: Called before all test cases
51 static void SetUpTestCase(void);
52 // TearDownTestCase: Called after all test case
53 static void TearDownTestCase(void);
54 // SetUp: Called before each test cases
55 void SetUp(void);
56 // TearDown: Called after each test cases
57 void TearDown(void);
58
59 public:
60 int fd1;
61 int64_t size;
62 };
63
SetUpTestCase()64 void DemuxerInnerApiNdkTest::SetUpTestCase() {}
TearDownTestCase()65 void DemuxerInnerApiNdkTest::TearDownTestCase() {}
66
SetUp()67 void DemuxerInnerApiNdkTest::SetUp()
68 {
69 fd1 = open(g_file1, O_RDONLY);
70 struct stat fileStatus {};
71 if (stat(g_file1, &fileStatus) == 0) {
72 size = static_cast<int64_t>(fileStatus.st_size);
73 }
74
75 std::cout << fd1 << "----------" << g_file1 << "=====" << size << std::endl;
76 }
77
TearDown()78 void DemuxerInnerApiNdkTest::TearDown()
79 {
80 close(fd1);
81 fd1 = 0;
82
83 if (source != nullptr) {
84 source = nullptr;
85 }
86
87 if (demuxer != nullptr) {
88 demuxer = nullptr;
89 }
90 }
91 } // namespace
92
93 namespace {
94 /**
95 * @tc.number : DEMUXER_ILLEGAL_PARA_0100
96 * @tc.name : CreateWithURI para error
97 * @tc.desc : param test
98 */
99 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0100, TestSize.Level2)
100 {
101 source = AVSourceFactory::CreateWithURI("");
102 ASSERT_EQ(nullptr, source);
103 }
104
105 /**
106 * @tc.number : DEMUXER_ILLEGAL_PARA_0200
107 * @tc.name : CreateWithFD para error
108 * @tc.desc : param test
109 */
110 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0200, TestSize.Level2)
111 {
112 // fd must bigger than 2
113 source = AVSourceFactory::CreateWithFD(2, 0, 0);
114 ASSERT_EQ(nullptr, source);
115 }
116
117 /**
118 * @tc.number : DEMUXER_ILLEGAL_PARA_0300
119 * @tc.name : CreateWithFD para error
120 * @tc.desc : param test
121 */
122 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0300, TestSize.Level2)
123 {
124 // fd must bigger than 2
125 source = AVSourceFactory::CreateWithFD(3, 0, -1);
126 ASSERT_EQ(nullptr, source);
127 }
128
129 /**
130 * @tc.number : DEMUXER_ILLEGAL_PARA_0400
131 * @tc.name : CreateWithFD para error
132 * @tc.desc : param test
133 */
134 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0400, TestSize.Level2)
135 {
136 // fd must bigger than
137 source = AVSourceFactory::CreateWithFD(3, -1, 1);
138 ASSERT_EQ(nullptr, source);
139 }
140
141 /**
142 * @tc.number : DEMUXER_ILLEGAL_PARA_0500
143 * @tc.name : GetTrackFormat para error
144 * @tc.desc : param test
145 */
146 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0500, TestSize.Level2)
147 {
148 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
149 ASSERT_NE(nullptr, source);
150
151 Format format;
152 int32_t ret = source->GetTrackFormat(format, -1);
153 ASSERT_EQ(AVCS_ERR_INVALID_VAL, ret);
154 }
155
156 /**
157 * @tc.number : DEMUXER_ILLEGAL_PARA_0600
158 * @tc.name : CreateWithFD para error
159 * @tc.desc : param test
160 */
161 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0600, TestSize.Level2)
162 {
163 source = AVSourceFactory::CreateWithFD(fd1, 0, 0);
164 ASSERT_EQ(nullptr, source);
165 }
166
167 /**
168 * @tc.number : DEMUXER_ILLEGAL_PARA_0700
169 * @tc.name : CreateWithSource para error
170 * @tc.desc : param test
171 */
172 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0700, TestSize.Level2)
173 {
174 demuxer = AVDemuxerFactory::CreateWithSource(nullptr);
175 ASSERT_EQ(nullptr, demuxer);
176 }
177
178 /**
179 * @tc.number : DEMUXER_ILLEGAL_PARA_0800
180 * @tc.name : SelectTrackByID para error
181 * @tc.desc : param test
182 */
183 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0800, TestSize.Level2)
184 {
185 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
186 ASSERT_NE(nullptr, source);
187 demuxer = AVDemuxerFactory::CreateWithSource(source);
188 ASSERT_NE(nullptr, demuxer);
189 ASSERT_EQ(AVCS_ERR_INVALID_VAL, demuxer->SelectTrackByID(-1));
190 }
191
192 /**
193 * @tc.number : DEMUXER_ILLEGAL_PARA_0900
194 * @tc.name : UnselectTrackByID para error
195 * @tc.desc : param test
196 */
197 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_0900, TestSize.Level2)
198 {
199 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
200 ASSERT_NE(nullptr, source);
201 demuxer = AVDemuxerFactory::CreateWithSource(source);
202 ASSERT_NE(nullptr, demuxer);
203 ASSERT_EQ(AVCS_ERR_OK, demuxer->UnselectTrackByID(-1));
204 }
205
206 /**
207 * @tc.number : DEMUXER_ILLEGAL_PARA_1000
208 * @tc.name : ReadSample para error
209 * @tc.desc : param test
210 */
211 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_1000, TestSize.Level2)
212 {
213 int32_t size = g_width * g_height;
214 uint32_t trackIndex = -1;
215 uint8_t data[size];
216 std::shared_ptr<AVSharedMemoryBase> avMemBuffer = std::make_shared<AVSharedMemoryBase>
217 (size, AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
218 avMemBuffer->Init();
219 (void)memcpy_s(avMemBuffer->GetBase(), avMemBuffer->GetSize(), data, size);
220
221 AVCodecBufferInfo info;
222 uint32_t flag;
223 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
224 ASSERT_NE(nullptr, source);
225 demuxer = AVDemuxerFactory::CreateWithSource(source);
226 ASSERT_NE(nullptr, demuxer);
227 ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, demuxer->ReadSample(trackIndex, avMemBuffer, info, flag));
228 }
229
230 /**
231 * @tc.number : DEMUXER_ILLEGAL_PARA_1100
232 * @tc.name : ReadSample para error
233 * @tc.desc : param test
234 */
235 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_1100, TestSize.Level2)
236 {
237 uint8_t data[100];
238 std::shared_ptr<AVSharedMemoryBase> avMemBuffer = std::make_shared<AVSharedMemoryBase>(2,
239 AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
240 avMemBuffer->Init();
241 (void)memcpy_s(avMemBuffer->GetBase(), avMemBuffer->GetSize(), data, 2);
242
243 uint32_t trackIndex = 0;
244 AVCodecBufferInfo info;
245 uint32_t flag;
246 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
247 ASSERT_NE(nullptr, source);
248 demuxer = AVDemuxerFactory::CreateWithSource(source);
249 ASSERT_NE(nullptr, demuxer);
250 ASSERT_EQ(AVCS_ERR_OK, demuxer->SelectTrackByID(0));
251 ASSERT_EQ(AVCS_ERR_NO_MEMORY, demuxer->ReadSample(trackIndex, avMemBuffer, info, flag));
252 }
253
254 /**
255 * @tc.number : DEMUXER_ILLEGAL_PARA_1200
256 * @tc.name : ReadSample para error
257 * @tc.desc : param test
258 */
259 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_1200, TestSize.Level2)
260 {
261 uint8_t data[100];
262 std::shared_ptr<AVSharedMemoryBase> avMemBuffer = std::make_shared<AVSharedMemoryBase>(2,
263 AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
264 avMemBuffer->Init();
265 (void)memcpy_s(avMemBuffer->GetBase(), avMemBuffer->GetSize(), data, 2);
266
267 uint32_t trackIndex = 0;
268 AVCodecBufferInfo info;
269 uint32_t flag;
270 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
271 ASSERT_NE(nullptr, source);
272 demuxer = AVDemuxerFactory::CreateWithSource(source);
273 ASSERT_NE(nullptr, demuxer);
274 ASSERT_EQ(AVCS_ERR_INVALID_OPERATION, demuxer->ReadSample(trackIndex, avMemBuffer, info, flag));
275 }
276
277 /**
278 * @tc.number : DEMUXER_ILLEGAL_PARA_1300
279 * @tc.name : ReadSample para error
280 * @tc.desc : param test
281 */
282 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_1300, TestSize.Level2)
283 {
284 uint32_t trackIndex = 0;
285 AVCodecBufferInfo info;
286 uint32_t flag;
287 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
288 ASSERT_NE(nullptr, source);
289 demuxer = AVDemuxerFactory::CreateWithSource(source);
290 ASSERT_NE(nullptr, demuxer);
291 ASSERT_EQ(AVCS_ERR_INVALID_VAL, demuxer->ReadSample(trackIndex, nullptr, info, flag));
292 }
293
294 /**
295 * @tc.number : DEMUXER_ILLEGAL_PARA_1400
296 * @tc.name : Memory_Create para error
297 * @tc.desc : param test
298 */
299 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_ILLEGAL_PARA_1400, TestSize.Level2)
300 {
301 int32_t size = g_width * g_height;
302 uint8_t data[size];
303 std::shared_ptr<AVSharedMemoryBase> avMemBuffer = std::make_shared<AVSharedMemoryBase>
304 (size, AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
305 avMemBuffer->Init();
306 (void)memcpy_s(avMemBuffer->GetBase(), avMemBuffer->GetSize(), data, size);
307
308 ASSERT_NE(nullptr, avMemBuffer);
309 }
310
311 /**
312 * @tc.number : DEMUXER_API_0100
313 * @tc.name : CreateWithFD Repeat Call
314 * @tc.desc : api test
315 */
316 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0100, TestSize.Level2)
317 {
318 std::shared_ptr<AVSource> source1 = AVSourceFactory::CreateWithFD(fd1, 0, size);
319 ASSERT_NE(nullptr, source1);
320
321 int fd2 = open(g_file2, O_RDONLY);
322 int64_t size2 = 0;
323
324 struct stat fileStatus {};
325 if (stat(g_file2, &fileStatus) == 0) {
326 size2 = static_cast<int64_t>(fileStatus.st_size);
327 }
328 std::shared_ptr<AVSource> source2 = AVSourceFactory::CreateWithFD(fd2, 0, size2);
329 ASSERT_NE(nullptr, source2);
330 close(fd2);
331 }
332
333 /**
334 * @tc.number : DEMUXER_API_0200
335 * @tc.name : GetSourceFormat Repeat Call
336 * @tc.desc : api test
337 */
338 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0200, TestSize.Level2)
339 {
340 Format format;
341 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
342 ASSERT_NE(nullptr, source);
343
344 int32_t ret = source->GetSourceFormat(format);
345 ASSERT_EQ(AVCS_ERR_OK, ret);
346 ret = source->GetSourceFormat(format);
347 ASSERT_EQ(AVCS_ERR_OK, ret);
348 }
349
350 /**
351 * @tc.number : DEMUXER_API_0300
352 * @tc.name : GetTrackFormat Repeat Call
353 * @tc.desc : api test
354 */
355 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0300, TestSize.Level2)
356 {
357 Format format;
358 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
359 ASSERT_NE(nullptr, source);
360
361 int32_t ret = source->GetTrackFormat(format, 0);
362 ASSERT_EQ(AVCS_ERR_OK, ret);
363 ret = source->GetTrackFormat(format, 0);
364 ASSERT_EQ(AVCS_ERR_OK, ret);
365 }
366
367 /**
368 * @tc.number : DEMUXER_API_0400
369 * @tc.name : SelectTrackByID Repeat Call
370 * @tc.desc : api test
371 */
372 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0400, TestSize.Level2)
373 {
374 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
375 ASSERT_NE(nullptr, source);
376 demuxer = AVDemuxerFactory::CreateWithSource(source);
377 ASSERT_NE(nullptr, demuxer);
378
379 int32_t ret = demuxer->SelectTrackByID(0);
380 ASSERT_EQ(AVCS_ERR_OK, ret);
381 ret = demuxer->SelectTrackByID(0);
382 ASSERT_EQ(AVCS_ERR_OK, ret);
383 }
384
385 /**
386 * @tc.number : DEMUXER_API_0500
387 * @tc.name : UnselectTrackByID Repeat Call
388 * @tc.desc : api test
389 */
390 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0500, TestSize.Level2)
391 {
392 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
393 ASSERT_NE(nullptr, source);
394 demuxer = AVDemuxerFactory::CreateWithSource(source);
395 ASSERT_NE(nullptr, demuxer);
396
397 int32_t ret = demuxer->SelectTrackByID(0);
398 ASSERT_EQ(AVCS_ERR_OK, ret);
399 ret = demuxer->UnselectTrackByID(0);
400 ASSERT_EQ(AVCS_ERR_OK, ret);
401 ret = demuxer->UnselectTrackByID(0);
402 ASSERT_EQ(AVCS_ERR_OK, ret);
403 }
404
405 /**
406 * @tc.number : DEMUXER_API_0600
407 * @tc.name : ReadSample Repeat Call
408 * @tc.desc : api test
409 */
410 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0600, TestSize.Level2)
411 {
412 int32_t size = g_width * g_height;
413 uint8_t data[size];
414 std::shared_ptr<AVSharedMemoryBase> avMemBuffer = std::make_shared<AVSharedMemoryBase>
415 (size, AVSharedMemory::FLAGS_READ_WRITE, "userBuffer");
416 avMemBuffer->Init();
417 (void)memcpy_s(avMemBuffer->GetBase(), avMemBuffer->GetSize(), data, size);
418
419 AVCodecBufferInfo info;
420 uint32_t flag;
421 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
422 ASSERT_NE(nullptr, source);
423 demuxer = AVDemuxerFactory::CreateWithSource(source);
424 ASSERT_NE(nullptr, demuxer);
425
426 int32_t ret = demuxer->SelectTrackByID(0);
427 ASSERT_EQ(AVCS_ERR_OK, ret);
428 ret = demuxer->ReadSample(0, avMemBuffer, info, flag);
429 ASSERT_EQ(AVCS_ERR_OK, ret);
430 ret = demuxer->ReadSample(0, avMemBuffer, info, flag);
431 ASSERT_EQ(AVCS_ERR_OK, ret);
432 }
433
434 /**
435 * @tc.number : DEMUXER_API_0700
436 * @tc.name : SeekToTime Repeat Call
437 * @tc.desc : api test
438 */
439 HWTEST_F(DemuxerInnerApiNdkTest, DEMUXER_API_0700, TestSize.Level2)
440 {
441 uint32_t ms = 1000;
442 source = AVSourceFactory::CreateWithFD(fd1, 0, size);
443 ASSERT_NE(nullptr, source);
444 demuxer = AVDemuxerFactory::CreateWithSource(source);
445 ASSERT_NE(nullptr, demuxer);
446
447 int32_t ret = demuxer->SelectTrackByID(0);
448 ASSERT_EQ(AVCS_ERR_OK, ret);
449 ret = demuxer->SeekToTime(ms, SeekMode::SEEK_NEXT_SYNC);
450 ASSERT_EQ(AVCS_ERR_OK, ret);
451 ret = demuxer->SeekToTime(ms, SeekMode::SEEK_NEXT_SYNC);
452 ASSERT_EQ(AVCS_ERR_OK, ret);
453 }
454 } // namespace
455