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 #include <iostream>
16 #include <cstdio>
17 #include <atomic>
18 #include <fstream>
19 #include <thread>
20 #include <mutex>
21 #include <queue>
22 #include <string>
23 #include "gtest/gtest.h"
24 #include "videodec_sample.h"
25 #include "native_avcodec_videodecoder.h"
26 #include "native_avcodec_base.h"
27
28 using namespace std;
29 using namespace OHOS;
30 using namespace OHOS::Media;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Media {
35 class SwdecPerfNdkTest : public testing::Test {
36 public:
37 static void SetUpTestCase(); // 第一个测试用例执行前
38 static void TearDownTestCase(); // 最后一个测试用例执行后
39 void SetUp() override; // 每个测试用例执行前
40 void TearDown() override; // 每个测试用例执行后
41 void InputFunc();
42 void OutputFunc();
43 void Release();
44 int64_t GetSystemTimeUs();
45 int32_t Stop();
46
47 protected:
48 OH_AVCodec *vdec_;
49 bool createCodecSuccess_ = false;
50 const string CODEC_NAME = "video_decoder.avc";
51 const char *INP_DIR = "/data/test/media/1920_1080_20M_30.h264";
52
53 const char *INP_DIR_720_30 = "/data/test/media/1280_720_10M_30.h264";
54 const char *INP_DIR_720_60 = "/data/test/media/1280_720_10M_60.h264";
55 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_20M_30.h264";
56 const char *INP_DIR_1080_60 = "/data/test/media/1920_1080_20M_60.h264";
57 const char *INP_DIR_2160_30 = "/data/test/media/3840_2160_30M_30.h264";
58 const char *INP_DIR_2160_60 = "/data/test/media/3840_2160_30M_60.h264";
59
60 const char *INP_DIR_720_30_1 = "/data/test/media/1280_720_10M_30_1.h264";
61 const char *INP_DIR_720_60_1 = "/data/test/media/1280_720_10M_60_1.h264";
62 const char *INP_DIR_1080_30_1 = "/data/test/media/1920_1080_20M_30_1.h264";
63 const char *INP_DIR_1080_60_1 = "/data/test/media/1920_1080_20M_60_1.h264";
64 const char *INP_DIR_2160_30_1 = "/data/test/media/3840_2160_30M_30_1.h264";
65 const char *INP_DIR_2160_60_1 = "/data/test/media/3840_2160_30M_60_1.h264";
66 int64_t nanosInSecond = 1000000000L;
67 int64_t nanosInMicro = 1000L;
68 };
69 } // namespace Media
70 } // namespace OHOS
SetUpTestCase()71 void SwdecPerfNdkTest::SetUpTestCase() {}
TearDownTestCase()72 void SwdecPerfNdkTest::TearDownTestCase() {}
SetUp()73 void SwdecPerfNdkTest::SetUp() {}
74
TearDown()75 void SwdecPerfNdkTest::TearDown() {}
76
GetSystemTimeUs()77 int64_t SwdecPerfNdkTest::GetSystemTimeUs()
78 {
79 struct timespec now;
80 (void)clock_gettime(CLOCK_BOOTTIME, &now);
81 int64_t nanoTime = (int64_t)now.tv_sec * nanosInSecond + now.tv_nsec;
82 return nanoTime / nanosInMicro;
83 }
84
85 namespace {
86 /**
87 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0300
88 * @tc.name : surface API time test
89 * @tc.desc : perf test
90 */
91 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0300, TestSize.Level3)
92 {
93 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
94 vDecSample->INP_DIR = INP_DIR_1080_60;
95 vDecSample->OUT_DIR = "/data/test/media/1920_1080_60_out.rgba";
96 vDecSample->SURFACE_OUTPUT = true;
97 vDecSample->DEFAULT_WIDTH = 1920;
98 vDecSample->DEFAULT_HEIGHT = 1080;
99 vDecSample->DEFAULT_FRAME_RATE = 60;
100 vDecSample->sleepOnFPS = false;
101 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
102 vDecSample->WaitForEOS();
103 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
104 }
105
106 /**
107 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0400
108 * @tc.name : create 1 decoder(1920*1080 60fps)+2 decoder(1280*720 60fps)
109 * @tc.desc : perf test
110 */
111 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0400, TestSize.Level3)
112 {
113 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
114 vDecSample->INP_DIR = INP_DIR_1080_60;
115 vDecSample->SURFACE_OUTPUT = false;
116 vDecSample->DEFAULT_WIDTH = 1920;
117 vDecSample->DEFAULT_HEIGHT = 1080;
118 vDecSample->DEFAULT_FRAME_RATE = 60;
119 vDecSample->sleepOnFPS = false;
120 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
121 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
122 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
123 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
124
125 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
126 vDecSample1->INP_DIR = INP_DIR_720_60;
127 vDecSample1->SURFACE_OUTPUT = false;
128 vDecSample1->DEFAULT_WIDTH = 1280;
129 vDecSample1->DEFAULT_HEIGHT = 720;
130 vDecSample1->DEFAULT_FRAME_RATE = 60;
131 vDecSample1->sleepOnFPS = true;
132 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
133 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
134 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
135 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
136
137 shared_ptr<VDecNdkSample> vDecSample2 = make_shared<VDecNdkSample>();
138 vDecSample2->SURFACE_OUTPUT = false;
139 vDecSample2->INP_DIR = INP_DIR_720_30;
140 vDecSample2->DEFAULT_WIDTH = 1280;
141 vDecSample2->DEFAULT_HEIGHT = 720;
142 vDecSample2->DEFAULT_FRAME_RATE = 30;
143 vDecSample2->sleepOnFPS = true;
144 ASSERT_EQ(AV_ERR_OK, vDecSample2->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
145 ASSERT_EQ(AV_ERR_OK, vDecSample2->ConfigureVideoDecoder());
146 ASSERT_EQ(AV_ERR_OK, vDecSample2->SetVideoDecoderCallback());
147 ASSERT_EQ(AV_ERR_OK, vDecSample2->StartVideoDecoder());
148
149 vDecSample->WaitForEOS();
150 vDecSample1->WaitForEOS();
151 vDecSample2->WaitForEOS();
152 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
153 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
154 ASSERT_EQ(AV_ERR_OK, vDecSample2->errCount);
155 }
156
157 /**
158 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0500
159 * @tc.name : decode YUV time 1280*720 30fps 10M
160 * @tc.desc : perf test
161 */
162 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0500, TestSize.Level3)
163 {
164 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
165 vDecSample->SURFACE_OUTPUT = false;
166 vDecSample->INP_DIR = INP_DIR_720_30;
167 vDecSample->DEFAULT_WIDTH = 1280;
168 vDecSample->DEFAULT_HEIGHT = 720;
169 vDecSample->DEFAULT_FRAME_RATE = 30;
170 vDecSample->sleepOnFPS = false;
171 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
172 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
173 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
174 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
175 vDecSample->WaitForEOS();
176 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
177 }
178
179 /**
180 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0600
181 * @tc.name : decode Surface time 1280*720 30fps 10M
182 * @tc.desc : perf test
183 */
184 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0600, TestSize.Level3)
185 {
186 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
187 vDecSample->INP_DIR = INP_DIR_720_30;
188 vDecSample->SURFACE_OUTPUT = true;
189 vDecSample->DEFAULT_WIDTH = 1280;
190 vDecSample->DEFAULT_HEIGHT = 720;
191 vDecSample->DEFAULT_FRAME_RATE = 30;
192 vDecSample->sleepOnFPS = false;
193 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
194 vDecSample->WaitForEOS();
195 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
196 }
197
198 /**
199 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0700
200 * @tc.name : decode YUV time 1280*720 60fps 10M
201 * @tc.desc : perf test
202 */
203 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0700, TestSize.Level3)
204 {
205 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
206 vDecSample->INP_DIR = INP_DIR_720_60;
207 vDecSample->SURFACE_OUTPUT = false;
208 vDecSample->DEFAULT_WIDTH = 1280;
209 vDecSample->DEFAULT_HEIGHT = 720;
210 vDecSample->DEFAULT_FRAME_RATE = 60;
211 vDecSample->sleepOnFPS = false;
212 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
213 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
214 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
215 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
216 vDecSample->WaitForEOS();
217 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
218 }
219
220 /**
221 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0800
222 * @tc.name : decode Surface time 1280*720 60fps 10M
223 * @tc.desc : perf test
224 */
225 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0800, TestSize.Level3)
226 {
227 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
228 vDecSample->INP_DIR = INP_DIR_720_60;
229 vDecSample->SURFACE_OUTPUT = true;
230 vDecSample->DEFAULT_WIDTH = 1280;
231 vDecSample->DEFAULT_HEIGHT = 720;
232 vDecSample->DEFAULT_FRAME_RATE = 60;
233 vDecSample->sleepOnFPS = false;
234 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
235 vDecSample->WaitForEOS();
236 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
237 }
238
239 /**
240 * @tc.number : VIDEO_SWDEC_PERFORMANCE_0900
241 * @tc.name : decode YUV time 1920*1080 30fps 20M
242 * @tc.desc : perf test
243 */
244 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_0900, TestSize.Level3)
245 {
246 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
247 vDecSample->INP_DIR = INP_DIR_1080_30;
248 vDecSample->SURFACE_OUTPUT = false;
249 vDecSample->DEFAULT_WIDTH = 1920;
250 vDecSample->DEFAULT_HEIGHT = 1080;
251 vDecSample->DEFAULT_FRAME_RATE = 30;
252 vDecSample->sleepOnFPS = false;
253 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
254 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
255 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
256 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
257 vDecSample->WaitForEOS();
258 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
259 }
260
261 /**
262 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1000
263 * @tc.name : decode Surface time 1920*1080 30fps 20M
264 * @tc.desc : perf test
265 */
266 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1000, TestSize.Level3)
267 {
268 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
269 vDecSample->INP_DIR = INP_DIR_1080_30;
270 vDecSample->SURFACE_OUTPUT = true;
271 vDecSample->DEFAULT_WIDTH = 1920;
272 vDecSample->DEFAULT_HEIGHT = 1080;
273 vDecSample->DEFAULT_FRAME_RATE = 30;
274 vDecSample->sleepOnFPS = false;
275 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
276 vDecSample->WaitForEOS();
277 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
278 }
279
280 /**
281 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1100
282 * @tc.name : decode YUV time 1920*1080 60fps 20M
283 * @tc.desc : perf test
284 */
285 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1100, TestSize.Level3)
286 {
287 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
288 vDecSample->INP_DIR = INP_DIR_1080_60;
289 vDecSample->SURFACE_OUTPUT = false;
290 vDecSample->DEFAULT_WIDTH = 1920;
291 vDecSample->DEFAULT_HEIGHT = 1080;
292 vDecSample->DEFAULT_FRAME_RATE = 60;
293 vDecSample->sleepOnFPS = false;
294 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
295 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
296 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
297 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
298 vDecSample->WaitForEOS();
299 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
300 }
301
302 /**
303 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1200
304 * @tc.name : decode Surface time 1920*1080 60fps 20M
305 * @tc.desc : perf test
306 */
307 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1200, TestSize.Level3)
308 {
309 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
310 vDecSample->INP_DIR = INP_DIR_1080_60;
311 vDecSample->SURFACE_OUTPUT = true;
312 vDecSample->DEFAULT_WIDTH = 1920;
313 vDecSample->DEFAULT_HEIGHT = 1080;
314 vDecSample->DEFAULT_FRAME_RATE = 60;
315 vDecSample->sleepOnFPS = false;
316 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
317 vDecSample->WaitForEOS();
318 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
319 }
320
321 /**
322 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1300
323 * @tc.name : decode YUV time 3840*2160 30fps 50M
324 * @tc.desc : perf test
325 */
326 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1300, TestSize.Level3)
327 {
328 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
329 vDecSample->INP_DIR = INP_DIR_2160_30;
330 vDecSample->SURFACE_OUTPUT = false;
331 vDecSample->DEFAULT_WIDTH = 3840;
332 vDecSample->DEFAULT_HEIGHT = 2160;
333 vDecSample->DEFAULT_FRAME_RATE = 30;
334 vDecSample->sleepOnFPS = false;
335 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
336 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
337 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
338 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
339 vDecSample->WaitForEOS();
340 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
341 }
342
343 /**
344 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1400
345 * @tc.name : decode Surface time 3840*2160 30fps 50M
346 * @tc.desc : perf test
347 */
348 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1400, TestSize.Level3)
349 {
350 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
351 vDecSample->INP_DIR = INP_DIR_2160_30;
352 vDecSample->SURFACE_OUTPUT = true;
353 vDecSample->DEFAULT_WIDTH = 3840;
354 vDecSample->DEFAULT_HEIGHT = 2160;
355 vDecSample->DEFAULT_FRAME_RATE = 30;
356 vDecSample->sleepOnFPS = false;
357 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
358 vDecSample->WaitForEOS();
359 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
360 }
361
362 /**
363 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1500
364 * @tc.name : decode YUV time 3840*2160 60fps 50M
365 * @tc.desc : perf test
366 */
367 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1500, TestSize.Level3)
368 {
369 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
370 vDecSample->INP_DIR = INP_DIR_2160_60;
371 vDecSample->SURFACE_OUTPUT = false;
372 vDecSample->DEFAULT_WIDTH = 3840;
373 vDecSample->DEFAULT_HEIGHT = 2160;
374 vDecSample->DEFAULT_FRAME_RATE = 60;
375 vDecSample->sleepOnFPS = false;
376 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
377 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
378 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
379 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
380 vDecSample->WaitForEOS();
381 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
382 }
383
384 /**
385 * @tc.number : VIDEO_SWDEC_PERFORMANCE_1600
386 * @tc.name : decode Surface time 3840*2160 60fps 50M
387 * @tc.desc : perf test
388 */
389 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_1600, TestSize.Level3)
390 {
391 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
392 vDecSample->INP_DIR = INP_DIR_2160_60;
393 vDecSample->SURFACE_OUTPUT = true;
394 vDecSample->DEFAULT_WIDTH = 3840;
395 vDecSample->DEFAULT_HEIGHT = 2160;
396 vDecSample->DEFAULT_FRAME_RATE = 60;
397 vDecSample->sleepOnFPS = false;
398 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
399 vDecSample->WaitForEOS();
400 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
401 }
402
403 /**
404 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_0500
405 * @tc.name : decode YUV time 1280*720 30fps 10M
406 * @tc.desc : perf test
407 */
408 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_0500, TestSize.Level3)
409 {
410 for (int i = 0; i < 2; i++) {
411 VDecNdkSample *vDecSample = new VDecNdkSample();
412 vDecSample->SURFACE_OUTPUT = false;
413 if (i == 1) {
414 vDecSample->INP_DIR = INP_DIR_720_30_1;
415 } else {
416 vDecSample->INP_DIR = INP_DIR_720_30;
417 }
418 vDecSample->DEFAULT_WIDTH = 1280;
419 vDecSample->DEFAULT_HEIGHT = 720;
420 vDecSample->DEFAULT_FRAME_RATE = 30;
421 vDecSample->sleepOnFPS = false;
422 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
423 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
424 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
425 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
426 if (i == 1) {
427 vDecSample->WaitForEOS();
428 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
429 }
430 }
431 }
432
433 /**
434 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_0600
435 * @tc.name : decode Surface time 1280*720 30fps 10M
436 * @tc.desc : perf test
437 */
438 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_0600, TestSize.Level3)
439 {
440 for (int i = 0; i < 2; i++) {
441 VDecNdkSample *vDecSample = new VDecNdkSample();
442 if (i == 1) {
443 vDecSample->INP_DIR = INP_DIR_720_30;
444 } else {
445 vDecSample->INP_DIR = INP_DIR_720_30_1;
446 }
447 vDecSample->SURFACE_OUTPUT = true;
448 vDecSample->DEFAULT_WIDTH = 1280;
449 vDecSample->DEFAULT_HEIGHT = 720;
450 vDecSample->DEFAULT_FRAME_RATE = 30;
451 vDecSample->sleepOnFPS = false;
452 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
453 if (i == 1) {
454 vDecSample->WaitForEOS();
455 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
456 }
457 }
458 }
459
460 /**
461 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_0700
462 * @tc.name : decode YUV time 1280*720 60fps 10M
463 * @tc.desc : perf test
464 */
465 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_0700, TestSize.Level3)
466 {
467 for (int i = 0; i < 2; i++) {
468 VDecNdkSample *vDecSample = new VDecNdkSample();
469 vDecSample->SURFACE_OUTPUT = false;
470 if (i == 1) {
471 vDecSample->INP_DIR = INP_DIR_720_60_1;
472 } else {
473 vDecSample->INP_DIR = INP_DIR_720_60;
474 }
475 vDecSample->DEFAULT_WIDTH = 1280;
476 vDecSample->DEFAULT_HEIGHT = 720;
477 vDecSample->DEFAULT_FRAME_RATE = 30;
478 vDecSample->sleepOnFPS = false;
479 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
480 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
481 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
482 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
483 if (i == 1) {
484 vDecSample->WaitForEOS();
485 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
486 }
487 }
488 }
489
490 /**
491 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_0800
492 * @tc.name : decode Surface time 1280*720 60fps 10M
493 * @tc.desc : perf test
494 */
495 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_0800, TestSize.Level3)
496 {
497 for (int i = 0; i < 2; i++) {
498 VDecNdkSample *vDecSample = new VDecNdkSample();
499 if (i == 1) {
500 vDecSample->INP_DIR = INP_DIR_720_60;
501 } else {
502 vDecSample->INP_DIR = INP_DIR_720_60_1;
503 }
504 vDecSample->SURFACE_OUTPUT = true;
505 vDecSample->DEFAULT_WIDTH = 1280;
506 vDecSample->DEFAULT_HEIGHT = 720;
507 vDecSample->DEFAULT_FRAME_RATE = 30;
508 vDecSample->sleepOnFPS = false;
509 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
510 if (i == 1) {
511 vDecSample->WaitForEOS();
512 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
513 }
514 }
515 }
516
517 /**
518 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_0900
519 * @tc.name : decode YUV time 1920*1080 30fps 20M
520 * @tc.desc : perf test
521 */
522 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_0900, TestSize.Level3)
523 {
524 for (int i = 0; i < 2; i++) {
525 VDecNdkSample *vDecSample = new VDecNdkSample();
526 vDecSample->SURFACE_OUTPUT = false;
527 if (i == 1) {
528 vDecSample->INP_DIR = INP_DIR_1080_30_1;
529 } else {
530 vDecSample->INP_DIR = INP_DIR_1080_30;
531 }
532 vDecSample->DEFAULT_WIDTH = 1280;
533 vDecSample->DEFAULT_HEIGHT = 720;
534 vDecSample->DEFAULT_FRAME_RATE = 30;
535 vDecSample->sleepOnFPS = false;
536 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
537 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
538 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
539 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
540 if (i == 1) {
541 vDecSample->WaitForEOS();
542 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
543 }
544 }
545 }
546
547 /**
548 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1000
549 * @tc.name : decode Surface time 1920*1080 30fps 20M
550 * @tc.desc : perf test
551 */
552 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1000, TestSize.Level3)
553 {
554 for (int i = 0; i < 2; i++) {
555 VDecNdkSample *vDecSample = new VDecNdkSample();
556 if (i == 1) {
557 vDecSample->INP_DIR = INP_DIR_1080_30;
558 } else {
559 vDecSample->INP_DIR = INP_DIR_1080_30_1;
560 }
561 vDecSample->SURFACE_OUTPUT = true;
562 vDecSample->DEFAULT_WIDTH = 1280;
563 vDecSample->DEFAULT_HEIGHT = 720;
564 vDecSample->DEFAULT_FRAME_RATE = 30;
565 vDecSample->sleepOnFPS = false;
566 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
567 if (i == 1) {
568 vDecSample->WaitForEOS();
569 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
570 }
571 }
572 }
573
574 /**
575 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1100
576 * @tc.name : decode YUV time 1920*1080 60fps 20M
577 * @tc.desc : perf test
578 */
579 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1100, TestSize.Level3)
580 {
581 for (int i = 0; i < 2; i++) {
582 VDecNdkSample *vDecSample = new VDecNdkSample();
583 vDecSample->SURFACE_OUTPUT = false;
584 if (i == 1) {
585 vDecSample->INP_DIR = INP_DIR_1080_60_1;
586 } else {
587 vDecSample->INP_DIR = INP_DIR_1080_60;
588 }
589 vDecSample->DEFAULT_WIDTH = 1280;
590 vDecSample->DEFAULT_HEIGHT = 720;
591 vDecSample->DEFAULT_FRAME_RATE = 30;
592 vDecSample->sleepOnFPS = false;
593 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
594 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
595 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
596 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
597 if (i == 1) {
598 vDecSample->WaitForEOS();
599 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
600 }
601 }
602 }
603
604 /**
605 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1200
606 * @tc.name : decode Surface time 1920*1080 60fps 20M
607 * @tc.desc : perf test
608 */
609 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1200, TestSize.Level3)
610 {
611 for (int i = 0; i < 2; i++) {
612 VDecNdkSample *vDecSample = new VDecNdkSample();
613 if (i == 1) {
614 vDecSample->INP_DIR = INP_DIR_1080_60;
615 } else {
616 vDecSample->INP_DIR = INP_DIR_1080_60_1;
617 }
618 vDecSample->SURFACE_OUTPUT = true;
619 vDecSample->DEFAULT_WIDTH = 1280;
620 vDecSample->DEFAULT_HEIGHT = 720;
621 vDecSample->DEFAULT_FRAME_RATE = 30;
622 vDecSample->sleepOnFPS = false;
623 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
624 if (i == 1) {
625 vDecSample->WaitForEOS();
626 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
627 }
628 }
629 }
630
631 /**
632 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1300
633 * @tc.name : decode YUV time 3840*2160 30fps 50M
634 * @tc.desc : perf test
635 */
636 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1300, TestSize.Level3)
637 {
638 for (int i = 0; i < 2; i++) {
639 VDecNdkSample *vDecSample = new VDecNdkSample();
640 vDecSample->SURFACE_OUTPUT = false;
641 if (i == 1) {
642 vDecSample->INP_DIR = INP_DIR_2160_30_1;
643 } else {
644 vDecSample->INP_DIR = INP_DIR_2160_30;
645 }
646 vDecSample->DEFAULT_WIDTH = 1280;
647 vDecSample->DEFAULT_HEIGHT = 720;
648 vDecSample->DEFAULT_FRAME_RATE = 30;
649 vDecSample->sleepOnFPS = false;
650 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
651 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
652 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
653 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
654 if (i == 1) {
655 vDecSample->WaitForEOS();
656 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
657 }
658 }
659 }
660
661 /**
662 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1400
663 * @tc.name : decode Surface time 3840*2160 30fps 50M
664 * @tc.desc : perf test
665 */
666 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1400, TestSize.Level3)
667 {
668 for (int i = 0; i < 2; i++) {
669 VDecNdkSample *vDecSample = new VDecNdkSample();
670 if (i == 1) {
671 vDecSample->INP_DIR = INP_DIR_2160_30;
672 } else {
673 vDecSample->INP_DIR = INP_DIR_2160_30_1;
674 }
675 vDecSample->SURFACE_OUTPUT = true;
676 vDecSample->DEFAULT_WIDTH = 1280;
677 vDecSample->DEFAULT_HEIGHT = 720;
678 vDecSample->DEFAULT_FRAME_RATE = 30;
679 vDecSample->sleepOnFPS = false;
680 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
681 if (i == 1) {
682 vDecSample->WaitForEOS();
683 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
684 }
685 }
686 }
687
688 /**
689 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1500
690 * @tc.name : decode YUV time 3840*2160 60fps 50M
691 * @tc.desc : perf test
692 */
693 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1500, TestSize.Level3)
694 {
695 for (int i = 0; i < 2; i++) {
696 VDecNdkSample *vDecSample = new VDecNdkSample();
697 vDecSample->SURFACE_OUTPUT = false;
698 if (i == 1) {
699 vDecSample->INP_DIR = INP_DIR_2160_60_1;
700 } else {
701 vDecSample->INP_DIR = INP_DIR_2160_60;
702 }
703 vDecSample->DEFAULT_WIDTH = 1280;
704 vDecSample->DEFAULT_HEIGHT = 720;
705 vDecSample->DEFAULT_FRAME_RATE = 30;
706 vDecSample->sleepOnFPS = false;
707 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
708 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
709 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
710 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
711 if (i == 1) {
712 vDecSample->WaitForEOS();
713 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
714 }
715 }
716 }
717
718 /**
719 * @tc.number : VIDEO_SWDEC_PERFORMANCE_MORE_1600
720 * @tc.name : decode Surface time 3840*2160 60fps 50M
721 * @tc.desc : perf test
722 */
723 HWTEST_F(SwdecPerfNdkTest, VIDEO_SWDEC_PERFORMANCE_MORE_1600, TestSize.Level3)
724 {
725 for (int i = 0; i < 2; i++) {
726 VDecNdkSample *vDecSample = new VDecNdkSample();
727 if (i == 1) {
728 vDecSample->INP_DIR = INP_DIR_2160_60;
729 } else {
730 vDecSample->INP_DIR = INP_DIR_2160_60_1;
731 }
732 vDecSample->SURFACE_OUTPUT = true;
733 vDecSample->DEFAULT_WIDTH = 1280;
734 vDecSample->DEFAULT_HEIGHT = 720;
735 vDecSample->DEFAULT_FRAME_RATE = 30;
736 vDecSample->sleepOnFPS = false;
737 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
738 if (i == 1) {
739 vDecSample->WaitForEOS();
740 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
741 }
742 }
743 }
744 } // namespace