1 /*
2 * Copyright (C) 2022 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
23 #include <iostream>
24 #include <cstdio>
25 #include <string>
26 #include <fcntl.h>
27 namespace OHOS {
28 namespace Media {
29 class DemuxerPerfNdkTest : public testing::Test {
30 public:
31 // SetUpTestCase: Called before all test cases
32 static void SetUpTestCase(void);
33 // TearDownTestCase: Called after all test case
34 static void TearDownTestCase(void);
35 // SetUp: Called before each test cases
36 void SetUp(void);
37 // TearDown: Called after each test cases
38 void TearDown(void);
39 };
40
41 static OH_AVMemory *memory = nullptr;
42 static int32_t g_width = 3840;
43 static int32_t g_height = 2160;
44
SetUpTestCase()45 void DemuxerPerfNdkTest::SetUpTestCase()
46 {
47 OH_AVMemory_Create(g_width * g_height);
48 }
TearDownTestCase()49 void DemuxerPerfNdkTest::TearDownTestCase()
50 {
51 if (memory != nullptr) {
52 OH_AVMemory_Destroy(memory);
53 }
54 }
SetUp()55 void DemuxerPerfNdkTest::SetUp() {}
TearDown()56 void DemuxerPerfNdkTest::TearDown() {}
57 } // namespace Media
58 } // namespace OHOS
59
60 using namespace std;
61 using namespace OHOS;
62 using namespace OHOS::Media;
63 using namespace testing::ext;
64
65 namespace {
66 /**
67 * @tc.number : DEMUXER_MEMORY_0100
68 * @tc.name : demux memory 1280x720 30fps 10M
69 * @tc.desc : performance test
70 */
71 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_MEMORY_0100, TestSize.Level3)
72 {
73 const char *file = "/data/test/media/1280x720_30.mp4";
74 OH_AVErrCode ret = AV_ERR_OK;
75 uint32_t trackIndex = 0;
76 OH_AVCodecBufferAttr attr;
77 int fd = open(file, O_RDONLY);
78 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
79 ASSERT_NE(source, nullptr);
80 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
81 ASSERT_NE(demuxer, nullptr);
82 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
83 ASSERT_EQ(ret, AV_ERR_OK);
84 while ((attr.flags & AVCODEC_BUFFER_FLAGS_EOS) != 0) {
85 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
86 ASSERT_EQ(ret, AV_ERR_OK);
87 }
88 OH_AVSource_Destroy(source);
89 close(fd);
90 fd = -1;
91 }
92
93 /**
94 * @tc.number : DEMUXER_MEMORY_0200
95 * @tc.name : demux memory 1920x1080 30fps 20M
96 * @tc.desc : performance test
97 */
98 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_MEMORY_0200, TestSize.Level3)
99 {
100 const char *file = "/data/test/media/1920x1080_30.mp4";
101 OH_AVErrCode ret = AV_ERR_OK;
102 OH_AVCodecBufferAttr attr;
103 int fd = open(file, O_RDONLY);
104 uint32_t trackIndex = 0;
105 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
106 ASSERT_NE(source, nullptr);
107 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
108 ASSERT_NE(demuxer, nullptr);
109 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
110 ASSERT_EQ(ret, AV_ERR_OK);
111 while ((attr.flags & AVCODEC_BUFFER_FLAGS_EOS) != 0) {
112 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
113 ASSERT_EQ(ret, AV_ERR_OK);
114 }
115 OH_AVSource_Destroy(source);
116 close(fd);
117 fd = -1;
118 }
119
120 /**
121 * @tc.number : DEMUXER_MEMORY_0300
122 * @tc.name : demux memory 1280x720 30fps 50M
123 * @tc.desc : performance test
124 */
125 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_MEMORY_0300, TestSize.Level3)
126 {
127 const char *file = "/data/test/media/3840x2160_30.mp4";
128 OH_AVErrCode ret = AV_ERR_OK;
129 OH_AVCodecBufferAttr attr;
130 uint32_t trackIndex = 0;
131 int fd = open(file, O_RDONLY);
132 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
133 ASSERT_NE(source, nullptr);
134 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
135 ASSERT_NE(demuxer, nullptr);
136 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
137 ASSERT_EQ(ret, AV_ERR_OK);
138 while ((attr.flags & AVCODEC_BUFFER_FLAGS_EOS) != 0) {
139 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
140 ASSERT_EQ(ret, AV_ERR_OK);
141 }
142 OH_AVSource_Destroy(source);
143 close(fd);
144 fd = -1;
145 }
146
147 /**
148 * @tc.number : DEMUXER_PERFORMANCE_0100
149 * @tc.name : demux memory 1280x720 30fps 10M
150 * @tc.desc : performance test
151 */
152 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0100, TestSize.Level3)
153 {
154 const char *file = "/data/test/media/1280x720_30.mp4";
155 OH_AVErrCode ret = AV_ERR_OK;
156 OH_AVCodecBufferAttr attr;
157 uint32_t trackIndex = 0;
158 int fd = open(file, O_RDONLY);
159 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
160 ASSERT_NE(source, nullptr);
161 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
162 ASSERT_NE(demuxer, nullptr);
163 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
164 ASSERT_EQ(ret, AV_ERR_OK);
165 srand(time(nullptr));
166 for (int i = 0; i < 20; i++) {
167 int pos_to = rand() % (30 * 3600);
168 int64_t toMs = pos_to * 33333;
169 ret = OH_AVDemuxer_SeekToTime(demuxer, toMs, SEEK_NEXT_SYNC);
170 ASSERT_EQ(ret, AV_ERR_OK);
171 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
172 ASSERT_EQ(ret, AV_ERR_OK);
173 }
174 OH_AVSource_Destroy(source);
175 close(fd);
176 fd = -1;
177 }
178
179 /**
180 * @tc.number : DEMUXER_PERFORMANCE_0200
181 * @tc.name : demux memory 1280x720 60fps 10M
182 * @tc.desc : performance test
183 */
184 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0200, TestSize.Level3)
185 {
186 const char *file = "/data/test/media/1280x720_60.mp4";
187 OH_AVErrCode ret = AV_ERR_OK;
188 OH_AVCodecBufferAttr attr;
189 int fd = open(file, O_RDONLY);
190 uint32_t trackIndex = 0;
191 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
192 ASSERT_NE(source, nullptr);
193 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
194 ASSERT_NE(demuxer, nullptr);
195 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
196 ASSERT_EQ(ret, AV_ERR_OK);
197 srand(time(nullptr));
198 for (int i = 0; i < 20; i++) {
199 int pos_to = rand() % (60 * 3600);
200 int64_t toMs = pos_to * 16666;
201 ret = OH_AVDemuxer_SeekToTime(demuxer, toMs, SEEK_NEXT_SYNC);
202 ASSERT_EQ(ret, AV_ERR_OK);
203 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
204 ASSERT_EQ(ret, AV_ERR_OK);
205 }
206 OH_AVSource_Destroy(source);
207 close(fd);
208 fd = -1;
209 }
210
211 /**
212 * @tc.number : DEMUXER_PERFORMANCE_0300
213 * @tc.name : demux memory 1920x1080 30fps 20M
214 * @tc.desc : performance test
215 */
216 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0300, TestSize.Level3)
217 {
218 const char *file = "/data/test/media/1920x1080_30.mp4";
219 OH_AVErrCode ret = AV_ERR_OK;
220 OH_AVCodecBufferAttr attr;
221 uint32_t trackIndex = 0;
222 int fd = open(file, O_RDONLY);
223 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
224 ASSERT_NE(source, nullptr);
225 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
226 ASSERT_NE(demuxer, nullptr);
227 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
228 ASSERT_EQ(ret, AV_ERR_OK);
229 srand(time(nullptr));
230 for (int i = 0; i < 20; i++) {
231 int pos_to = rand() % (30 * 3600);
232 int64_t toMs = pos_to * 33333;
233 ret = OH_AVDemuxer_SeekToTime(demuxer, toMs, SEEK_NEXT_SYNC);
234 ASSERT_EQ(ret, AV_ERR_OK);
235 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
236 ASSERT_EQ(ret, AV_ERR_OK);
237 }
238 OH_AVSource_Destroy(source);
239 close(fd);
240 fd = -1;
241 }
242
243 /**
244 * @tc.number : DEMUXER_PERFORMANCE_0400
245 * @tc.name : demux memory 1920x1080 60fps 20M
246 * @tc.desc : performance test
247 */
248 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0400, TestSize.Level3)
249 {
250 const char *file = "/data/test/media/1920x1080_60.mp4";
251 OH_AVErrCode ret = AV_ERR_OK;
252 OH_AVCodecBufferAttr attr;
253 uint32_t trackIndex = 0;
254 int fd = open(file, O_RDONLY);
255 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
256 ASSERT_NE(source, nullptr);
257 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
258 ASSERT_NE(demuxer, nullptr);
259 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
260 ASSERT_EQ(ret, AV_ERR_OK);
261 srand(time(nullptr));
262 for (int i = 0; i < 20; i++) {
263 int pos_to = rand() % (60 * 3600);
264 int64_t toMs = pos_to * 16666;
265 ret = OH_AVDemuxer_SeekToTime(demuxer, toMs, SEEK_NEXT_SYNC);
266 ASSERT_EQ(ret, AV_ERR_OK);
267 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
268 ASSERT_EQ(ret, AV_ERR_OK);
269 }
270 OH_AVSource_Destroy(source);
271 close(fd);
272 fd = -1;
273 }
274
275 /**
276 * @tc.number : DEMUXER_PERFORMANCE_0500
277 * @tc.name : demux memory 3840x2160 30fps 50M
278 * @tc.desc : performance test
279 */
280 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0500, TestSize.Level3)
281 {
282 const char *file = "/data/test/media/3840x2160_30.mp4";
283 OH_AVErrCode ret = AV_ERR_OK;
284 OH_AVCodecBufferAttr attr;
285 uint32_t trackIndex = 0;
286 int fd = open(file, O_RDONLY);
287 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
288 ASSERT_NE(source, nullptr);
289 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
290 ASSERT_NE(demuxer, nullptr);
291 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
292 ASSERT_EQ(ret, AV_ERR_OK);
293 srand(time(nullptr));
294 for (int i = 0; i < 20; i++) {
295 int pos_to = rand() % (30 * 3600);
296 int64_t toMs = pos_to * 33333;
297 ret = OH_AVDemuxer_SeekToTime(demuxer, toMs, SEEK_NEXT_SYNC);
298 ASSERT_EQ(ret, AV_ERR_OK);
299 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
300 ASSERT_EQ(ret, AV_ERR_OK);
301 }
302 OH_AVSource_Destroy(source);
303 close(fd);
304 fd = -1;
305 }
306
307 /**
308 * @tc.number : DEMUXER_PERFORMANCE_0600
309 * @tc.name : demux memory 3840x2160 60fps 50M
310 * @tc.desc : performance test
311 */
312 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0600, TestSize.Level3)
313 {
314 const char *file = "/data/test/media/3840x2160_60.mp4";
315 OH_AVErrCode ret = AV_ERR_OK;
316 OH_AVCodecBufferAttr attr;
317 uint32_t trackIndex = 0;
318 int fd = open(file, O_RDONLY);
319 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
320 ASSERT_NE(source, nullptr);
321 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
322 ASSERT_NE(demuxer, nullptr);
323 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
324 ASSERT_EQ(ret, AV_ERR_OK);
325 srand(time(nullptr));
326 for (int i = 0; i < 20; i++) {
327 int pos_to = rand() % (60 * 3600);
328 int64_t toMs = pos_to * 16666;
329 ret = OH_AVDemuxer_SeekToTime(demuxer, toMs, SEEK_NEXT_SYNC);
330 ASSERT_EQ(ret, AV_ERR_OK);
331 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
332 ASSERT_EQ(ret, AV_ERR_OK);
333 }
334 OH_AVSource_Destroy(source);
335 close(fd);
336 fd = -1;
337 }
338
339 /**
340 * @tc.number : DEMUXER_PERFORMANCE_0700
341 * @tc.name : test CopyNextSample time 1280x720 30fps 10M
342 * @tc.desc : performance test
343 */
344 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0700, TestSize.Level3)
345 {
346 const char *file = "/data/test/media/1280x720_30_10M.mp4";
347 OH_AVErrCode ret = AV_ERR_OK;
348 OH_AVCodecBufferAttr attr;
349 uint32_t trackIndex = 0;
350 int fd = open(file, O_RDONLY);
351 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
352 ASSERT_NE(source, nullptr);
353 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
354 ASSERT_NE(demuxer, nullptr);
355 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
356 ASSERT_EQ(ret, AV_ERR_OK);
357 while ((attr.flags & AVCODEC_BUFFER_FLAGS_EOS) != 0) {
358 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
359 ASSERT_EQ(ret, AV_ERR_OK);
360 }
361 OH_AVSource_Destroy(source);
362 close(fd);
363 fd = -1;
364 }
365
366 /**
367 * @tc.number : DEMUXER_PERFORMANCE_0800
368 * @tc.name : test CopyNextSample time 1920x1080 30fps 20M
369 * @tc.desc : performance test
370 */
371 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0800, TestSize.Level3)
372 {
373 const char *file = "/data/test/media/1920x1080_30.mp4";
374 OH_AVErrCode ret = AV_ERR_OK;
375 OH_AVCodecBufferAttr attr;
376 uint32_t trackIndex = 0;
377 int fd = open(file, O_RDONLY);
378 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
379 ASSERT_NE(source, nullptr);
380 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
381 ASSERT_NE(demuxer, nullptr);
382 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
383 ASSERT_EQ(ret, AV_ERR_OK);
384 while ((attr.flags & AVCODEC_BUFFER_FLAGS_EOS) != 0) {
385 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
386 ASSERT_EQ(ret, AV_ERR_OK);
387 }
388 OH_AVSource_Destroy(source);
389 close(fd);
390 fd = -1;
391 }
392
393 /**
394 * @tc.number : DEMUXER_PERFORMANCE_0900
395 * @tc.name : test CopyNextSample time 3840x2160 30fps 50M
396 * @tc.desc : performance test
397 */
398 HWTEST_F(DemuxerPerfNdkTest, DEMUXER_PERFORMANCE_0900, TestSize.Level3)
399 {
400 const char *file = "/data/test/media/3840x2160_30.mp4";
401 OH_AVErrCode ret = AV_ERR_OK;
402 OH_AVCodecBufferAttr attr;
403 uint32_t trackIndex = 0;
404 int fd = open(file, O_RDONLY);
405 OH_AVSource *source = OH_AVSource_CreateWithFD(fd, 0, 0);
406 ASSERT_NE(source, nullptr);
407 OH_AVDemuxer *demuxer = OH_AVDemuxer_CreateWithSource(source);
408 ASSERT_NE(demuxer, nullptr);
409 ret = OH_AVDemuxer_SelectTrackByID(demuxer, 0);
410 ASSERT_EQ(ret, AV_ERR_OK);
411 while ((attr.flags & AVCODEC_BUFFER_FLAGS_EOS) != 0) {
412 ret = OH_AVDemuxer_ReadSample(demuxer, trackIndex, memory, &attr);
413 ASSERT_EQ(ret, AV_ERR_OK);
414 }
415 OH_AVSource_Destroy(source);
416 close(fd);
417 fd = -1;
418 }
419 }