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 <iostream>
17 #include <cstdio>
18 #include <atomic>
19 #include <fstream>
20 #include <thread>
21 #include <mutex>
22 #include <queue>
23 #include <string>
24
25 #include "gtest/gtest.h"
26 #include "videodec_sample.h"
27 #include "native_avcodec_videodecoder.h"
28 #include "native_avcodec_base.h"
29 #include "native_avcapability.h"
30
31 using namespace std;
32 using namespace OHOS;
33 using namespace OHOS::Media;
34 using namespace testing::ext;
35 namespace {
36 string g_codecName;
37 string g_codecNameHEVC;
38 OH_AVCapability *cap = nullptr;
39 OH_AVCapability *cap_hevc = nullptr;
40 constexpr uint32_t MAX_THREAD = 16;
41 } // namespace
42 namespace OHOS {
43 namespace Media {
44 class HwdecPerfNdkTest : public testing::Test {
45 public:
46 static void SetUpTestCase(); // 第一个测试用例执行前
47 static void TearDownTestCase(); // 最后一个测试用例执行后
48 void SetUp() override; // 每个测试用例执行前
49 void TearDown() override; // 每个测试用例执行后
50 void InputFunc();
51 void OutputFunc();
52 void Release();
53 int64_t GetSystemTimeUs();
54 int32_t Stop();
55
56 protected:
57 OH_AVCodec *vdec_;
58 bool createCodecSuccess_ = false;
59 const char *INP_DIR = "/data/test/media/1920x1080_30_10M.h264";
60 const char *INP_DIR_720_30 = "/data/test/media/1280x720_30_10M.h264";
61 const char *INP_DIR_1080_30 = "/data/test/media/1920x1080_30_10M.h264";
62 const char *INP_DIR_2160_30 = "/data/test/media/3840x2160_30_50M.h264";
63 const char *INP_DIR_720_60 = "/data/test/media/1280x720_60_10Mb.h264";
64 const char *INP_DIR_1080_60 = "/data/test/media/1920x1080_60_20Mb.h264";
65 const char *INP_DIR_2160_60 = "/data/test/media/3840x2160_60_50Mb.h264";
66
67 const char *INP_DIR_720_30_1 = "/data/test/media/1280x720_30_10M_1.h264";
68 const char *INP_DIR_1080_30_1 = "/data/test/media/1920x1080_30_10M_1.h264";
69 const char *INP_DIR_2160_30_1 = "/data/test/media/3840x2160_30_50M_1.h264";
70 const char *INP_DIR_720_60_1 = "/data/test/media/1280x720_60_10Mb_1.h264";
71 const char *INP_DIR_1080_60_1 = "/data/test/media/1920x1080_60_20Mb_1.h264";
72 const char *INP_DIR_2160_60_1 = "/data/test/media/3840x2160_60_50Mb_1.h264";
73
74 const char *INP_DIR_720_30_264 = "/data/test/media/1280_720_10M_30.h264";
75 const char *INP_DIR_720_60_264 = "/data/test/media/1280_720_10M_60.h264";
76 const char *INP_DIR_1080_30_264 = "/data/test/media/1920_1080_20M_30.h264";
77 const char *INP_DIR_1080_60_264 = "/data/test/media/1920_1080_20M_60.h264";
78 const char *INP_DIR_2160_30_264 = "/data/test/media/3840_2160_30M_30.h264";
79 const char *INP_DIR_2160_60_264 = "/data/test/media/3840_2160_30M_60.h264";
80
81 const char *INP_DIR_720_30_265 = "/data/test/media/1280_720_10M_30.h265";
82 const char *INP_DIR_720_60_265 = "/data/test/media/1280_720_10M_60.h265";
83 const char *INP_DIR_1080_30_265 = "/data/test/media/1920_1080_20M_30.h265";
84 const char *INP_DIR_1080_60_265 = "/data/test/media/1920_1080_20M_60.h265";
85 const char *INP_DIR_2160_30_265 = "/data/test/media/3840_2160_30M_30.h265";
86 const char *INP_DIR_2160_60_265 = "/data/test/media/3840_2160_30M_60.h265";
87 int64_t NANOS_IN_SECOND = 1000000000L;
88 int64_t NANOS_IN_MICRO = 1000L;
89 };
90 } // namespace Media
91 } // namespace OHOS
SetUpTestCase()92 void HwdecPerfNdkTest::SetUpTestCase()
93 {
94 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
95 g_codecName = OH_AVCapability_GetName(cap);
96 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
97 g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
98 }
TearDownTestCase()99 void HwdecPerfNdkTest::TearDownTestCase() {}
SetUp()100 void HwdecPerfNdkTest::SetUp() {}
101
TearDown()102 void HwdecPerfNdkTest::TearDown() {}
103
GetSystemTimeUs()104 int64_t HwdecPerfNdkTest::GetSystemTimeUs()
105 {
106 struct timespec now;
107 (void)clock_gettime(CLOCK_BOOTTIME, &now);
108 int64_t nanoTime = (int64_t)now.tv_sec * NANOS_IN_SECOND + now.tv_nsec;
109 return nanoTime / NANOS_IN_MICRO;
110 }
111
112 namespace {
113 /**
114 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0100
115 * @tc.name : test surface mode memory performance
116 * @tc.desc : function test
117 */
118 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0100, TestSize.Level3)
119 {
120 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
121 vDecSample->SF_OUTPUT = true;
122 vDecSample->INP_DIR = INP_DIR_720_30_264;
123 vDecSample->DEFAULT_WIDTH = 1280;
124 vDecSample->DEFAULT_HEIGHT = 720;
125 vDecSample->DEFAULT_FRAME_RATE = 30;
126 vDecSample->sleepOnFPS = false;
127 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
128 vDecSample->WaitForEOS();
129 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
130 }
131
132 /**
133 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0200
134 * @tc.name : test surface mode memory performance
135 * @tc.desc : function test
136 */
137 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0200, TestSize.Level3)
138 {
139 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
140 vDecSample->SF_OUTPUT = true;
141 vDecSample->INP_DIR = INP_DIR_720_60_264;
142 vDecSample->DEFAULT_WIDTH = 1280;
143 vDecSample->DEFAULT_HEIGHT = 720;
144 vDecSample->DEFAULT_FRAME_RATE = 60;
145 vDecSample->sleepOnFPS = false;
146 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
147 vDecSample->WaitForEOS();
148 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
149 }
150
151 /**
152 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0300
153 * @tc.name : test surface mode memory performance
154 * @tc.desc : function test
155 */
156 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0300, TestSize.Level3)
157 {
158 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
159 vDecSample->SF_OUTPUT = true;
160 vDecSample->INP_DIR = INP_DIR_1080_30_264;
161 vDecSample->DEFAULT_WIDTH = 1920;
162 vDecSample->DEFAULT_HEIGHT = 1080;
163 vDecSample->DEFAULT_FRAME_RATE = 30;
164 vDecSample->sleepOnFPS = false;
165 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
166 vDecSample->WaitForEOS();
167 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
168 }
169
170 /**
171 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0400
172 * @tc.name : test surface mode memory performance
173 * @tc.desc : function test
174 */
175 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0400, TestSize.Level3)
176 {
177 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
178 vDecSample->SF_OUTPUT = true;
179 vDecSample->INP_DIR = INP_DIR_1080_60_264;
180 vDecSample->DEFAULT_WIDTH = 1920;
181 vDecSample->DEFAULT_HEIGHT = 1080;
182 vDecSample->DEFAULT_FRAME_RATE = 60;
183 vDecSample->sleepOnFPS = false;
184 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
185 vDecSample->WaitForEOS();
186 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
187 }
188
189 /**
190 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0500
191 * @tc.name : test surface mode memory performance
192 * @tc.desc : function test
193 */
194 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0500, TestSize.Level3)
195 {
196 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
197 vDecSample->SF_OUTPUT = true;
198 vDecSample->INP_DIR = INP_DIR_2160_30_264;
199 vDecSample->DEFAULT_WIDTH = 3840;
200 vDecSample->DEFAULT_HEIGHT = 2160;
201 vDecSample->DEFAULT_FRAME_RATE = 30;
202 vDecSample->sleepOnFPS = false;
203 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
204 vDecSample->WaitForEOS();
205 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
206 }
207
208 /**
209 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0600
210 * @tc.name : test surface mode memory performance
211 * @tc.desc : function test
212 */
213 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0600, TestSize.Level3)
214 {
215 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
216 vDecSample->SF_OUTPUT = true;
217 vDecSample->INP_DIR = INP_DIR_2160_60_264;
218 vDecSample->DEFAULT_WIDTH = 3840;
219 vDecSample->DEFAULT_HEIGHT = 2160;
220 vDecSample->DEFAULT_FRAME_RATE = 60;
221 vDecSample->sleepOnFPS = false;
222 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
223 vDecSample->WaitForEOS();
224 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
225 }
226
227 /**
228 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0700
229 * @tc.name : test surface mode memory performance
230 * @tc.desc : function test
231 */
232 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0700, TestSize.Level3)
233 {
234 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
235 vDecSample->SF_OUTPUT = true;
236 vDecSample->INP_DIR = INP_DIR_720_30_265;
237 vDecSample->DEFAULT_WIDTH = 1280;
238 vDecSample->DEFAULT_HEIGHT = 720;
239 vDecSample->DEFAULT_FRAME_RATE = 30;
240 vDecSample->sleepOnFPS = false;
241 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
242 vDecSample->WaitForEOS();
243 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
244 }
245
246 /**
247 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0800
248 * @tc.name : test surface mode memory performance
249 * @tc.desc : function test
250 */
251 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0800, TestSize.Level3)
252 {
253 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
254 vDecSample->SF_OUTPUT = true;
255 vDecSample->INP_DIR = INP_DIR_720_60_265;
256 vDecSample->DEFAULT_WIDTH = 1280;
257 vDecSample->DEFAULT_HEIGHT = 720;
258 vDecSample->DEFAULT_FRAME_RATE = 60;
259 vDecSample->sleepOnFPS = false;
260 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
261 vDecSample->WaitForEOS();
262 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
263 }
264
265 /**
266 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0900
267 * @tc.name : test surface mode memory performance
268 * @tc.desc : function test
269 */
270 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_0900, TestSize.Level3)
271 {
272 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
273 vDecSample->SF_OUTPUT = true;
274 vDecSample->INP_DIR = INP_DIR_1080_30_265;
275 vDecSample->DEFAULT_WIDTH = 1920;
276 vDecSample->DEFAULT_HEIGHT = 1080;
277 vDecSample->DEFAULT_FRAME_RATE = 30;
278 vDecSample->sleepOnFPS = false;
279 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
280 vDecSample->WaitForEOS();
281 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
282 }
283
284 /**
285 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_1000
286 * @tc.name : test surface mode memory performance
287 * @tc.desc : function test
288 */
289 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_1000, TestSize.Level3)
290 {
291 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
292 vDecSample->SF_OUTPUT = true;
293 vDecSample->INP_DIR = INP_DIR_1080_60_265;
294 vDecSample->DEFAULT_WIDTH = 1920;
295 vDecSample->DEFAULT_HEIGHT = 1080;
296 vDecSample->DEFAULT_FRAME_RATE = 60;
297 vDecSample->sleepOnFPS = false;
298 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
299 vDecSample->WaitForEOS();
300 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
301 }
302
303 /**
304 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_1100
305 * @tc.name : test surface mode memory performance
306 * @tc.desc : function test
307 */
308 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_1100, TestSize.Level3)
309 {
310 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
311 vDecSample->SF_OUTPUT = true;
312 vDecSample->INP_DIR = INP_DIR_2160_30_265;
313 vDecSample->DEFAULT_WIDTH = 3840;
314 vDecSample->DEFAULT_HEIGHT = 2160;
315 vDecSample->DEFAULT_FRAME_RATE = 30;
316 vDecSample->sleepOnFPS = false;
317 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
318 vDecSample->WaitForEOS();
319 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
320 }
321
322 /**
323 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_1200
324 * @tc.name : test surface mode memory performance
325 * @tc.desc : function test
326 */
327 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_SURFACE_1200, TestSize.Level3)
328 {
329 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
330 vDecSample->SF_OUTPUT = true;
331 vDecSample->INP_DIR = INP_DIR_2160_60_265;
332 vDecSample->DEFAULT_WIDTH = 3840;
333 vDecSample->DEFAULT_HEIGHT = 2160;
334 vDecSample->DEFAULT_FRAME_RATE = 60;
335 vDecSample->sleepOnFPS = false;
336 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
337 vDecSample->WaitForEOS();
338 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
339 }
340
341 /**
342 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0100
343 * @tc.name : test buffer mode memory performance
344 * @tc.desc : function test
345 */
346 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0100, TestSize.Level3)
347 {
348 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
349 vDecSample->SF_OUTPUT = false;
350 vDecSample->INP_DIR = INP_DIR_720_30_264;
351 vDecSample->DEFAULT_WIDTH = 1280;
352 vDecSample->DEFAULT_HEIGHT = 720;
353 vDecSample->DEFAULT_FRAME_RATE = 30;
354 vDecSample->sleepOnFPS = false;
355 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
356 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
357 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
358 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
359 vDecSample->WaitForEOS();
360 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
361 }
362
363 /**
364 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0200
365 * @tc.name : test buffer mode memory performance
366 * @tc.desc : function test
367 */
368 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0200, TestSize.Level3)
369 {
370 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
371 vDecSample->SF_OUTPUT = false;
372 vDecSample->INP_DIR = INP_DIR_720_60_264;
373 vDecSample->DEFAULT_WIDTH = 1280;
374 vDecSample->DEFAULT_HEIGHT = 720;
375 vDecSample->DEFAULT_FRAME_RATE = 60;
376 vDecSample->sleepOnFPS = false;
377 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
378 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
379 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
380 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
381 vDecSample->WaitForEOS();
382 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
383 }
384
385 /**
386 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0300
387 * @tc.name : test buffer mode memory performance
388 * @tc.desc : function test
389 */
390 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0300, TestSize.Level3)
391 {
392 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
393 vDecSample->SF_OUTPUT = false;
394 vDecSample->INP_DIR = INP_DIR_1080_30_264;
395 vDecSample->DEFAULT_WIDTH = 1920;
396 vDecSample->DEFAULT_HEIGHT = 1080;
397 vDecSample->DEFAULT_FRAME_RATE = 30;
398 vDecSample->sleepOnFPS = false;
399 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
400 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
401 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
402 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
403 vDecSample->WaitForEOS();
404 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
405 }
406
407 /**
408 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0400
409 * @tc.name : test buffer mode memory performance
410 * @tc.desc : function test
411 */
412 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0400, TestSize.Level3)
413 {
414 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
415 vDecSample->SF_OUTPUT = false;
416 vDecSample->INP_DIR = INP_DIR_1080_60_264;
417 vDecSample->DEFAULT_WIDTH = 1920;
418 vDecSample->DEFAULT_HEIGHT = 1080;
419 vDecSample->DEFAULT_FRAME_RATE = 60;
420 vDecSample->sleepOnFPS = false;
421 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
422 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
423 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
424 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
425 vDecSample->WaitForEOS();
426 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
427 }
428
429 /**
430 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0500
431 * @tc.name : test buffer mode memory performance
432 * @tc.desc : function test
433 */
434 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0500, TestSize.Level3)
435 {
436 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
437 vDecSample->SF_OUTPUT = false;
438 vDecSample->INP_DIR = INP_DIR_2160_30_264;
439 vDecSample->DEFAULT_WIDTH = 3840;
440 vDecSample->DEFAULT_HEIGHT = 2160;
441 vDecSample->DEFAULT_FRAME_RATE = 30;
442 vDecSample->sleepOnFPS = false;
443 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
444 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
445 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
446 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
447 vDecSample->WaitForEOS();
448 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
449 }
450
451 /**
452 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0600
453 * @tc.name : test buffer mode memory performance
454 * @tc.desc : function test
455 */
456 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0600, TestSize.Level3)
457 {
458 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
459 vDecSample->SF_OUTPUT = false;
460 vDecSample->INP_DIR = INP_DIR_2160_60_264;
461 vDecSample->DEFAULT_WIDTH = 3840;
462 vDecSample->DEFAULT_HEIGHT = 2160;
463 vDecSample->DEFAULT_FRAME_RATE = 60;
464 vDecSample->sleepOnFPS = false;
465 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
466 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
467 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
468 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
469 vDecSample->WaitForEOS();
470 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
471 }
472
473 /**
474 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0700
475 * @tc.name : test buffer mode memory performance
476 * @tc.desc : function test
477 */
478 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0700, TestSize.Level3)
479 {
480 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
481 vDecSample->SF_OUTPUT = false;
482 vDecSample->INP_DIR = INP_DIR_720_30_265;
483 vDecSample->DEFAULT_WIDTH = 1280;
484 vDecSample->DEFAULT_HEIGHT = 720;
485 vDecSample->DEFAULT_FRAME_RATE = 30;
486 vDecSample->sleepOnFPS = false;
487 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
488 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
489 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
490 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
491 vDecSample->WaitForEOS();
492 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
493 }
494
495 /**
496 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0800
497 * @tc.name : test buffer mode memory performance
498 * @tc.desc : function test
499 */
500 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0800, TestSize.Level3)
501 {
502 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
503 vDecSample->SF_OUTPUT = false;
504 vDecSample->INP_DIR = INP_DIR_720_60_265;
505 vDecSample->DEFAULT_WIDTH = 1280;
506 vDecSample->DEFAULT_HEIGHT = 720;
507 vDecSample->DEFAULT_FRAME_RATE = 60;
508 vDecSample->sleepOnFPS = false;
509 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
510 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
511 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
512 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
513 vDecSample->WaitForEOS();
514 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
515 }
516
517 /**
518 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_0900
519 * @tc.name : test buffer mode memory performance
520 * @tc.desc : function test
521 */
522 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_0900, TestSize.Level3)
523 {
524 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
525 vDecSample->SF_OUTPUT = false;
526 vDecSample->INP_DIR = INP_DIR_1080_30_265;
527 vDecSample->DEFAULT_WIDTH = 1920;
528 vDecSample->DEFAULT_HEIGHT = 1080;
529 vDecSample->DEFAULT_FRAME_RATE = 30;
530 vDecSample->sleepOnFPS = false;
531 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
532 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
533 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
534 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
535 vDecSample->WaitForEOS();
536 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
537 }
538
539 /**
540 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_1000
541 * @tc.name : test buffer mode memory performance
542 * @tc.desc : function test
543 */
544 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_1000, TestSize.Level3)
545 {
546 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
547 vDecSample->SF_OUTPUT = false;
548 vDecSample->INP_DIR = INP_DIR_1080_60_265;
549 vDecSample->DEFAULT_WIDTH = 1920;
550 vDecSample->DEFAULT_HEIGHT = 1080;
551 vDecSample->DEFAULT_FRAME_RATE = 60;
552 vDecSample->sleepOnFPS = false;
553 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
554 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
555 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
556 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
557 vDecSample->WaitForEOS();
558 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
559 }
560
561 /**
562 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_1100
563 * @tc.name : test buffer mode memory performance
564 * @tc.desc : function test
565 */
566 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_1100, TestSize.Level3)
567 {
568 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
569 vDecSample->SF_OUTPUT = false;
570 vDecSample->INP_DIR = INP_DIR_2160_30_265;
571 vDecSample->DEFAULT_WIDTH = 3840;
572 vDecSample->DEFAULT_HEIGHT = 2160;
573 vDecSample->DEFAULT_FRAME_RATE = 30;
574 vDecSample->sleepOnFPS = false;
575 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
576 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
577 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
578 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
579 vDecSample->WaitForEOS();
580 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
581 }
582
583 /**
584 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MEMORY_1200
585 * @tc.name : test buffer mode memory performance
586 * @tc.desc : function test
587 */
588 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MEMORY_1200, TestSize.Level3)
589 {
590 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
591 vDecSample->SF_OUTPUT = false;
592 vDecSample->INP_DIR = INP_DIR_2160_60_265;
593 vDecSample->DEFAULT_WIDTH = 3840;
594 vDecSample->DEFAULT_HEIGHT = 2160;
595 vDecSample->DEFAULT_FRAME_RATE = 60;
596 vDecSample->sleepOnFPS = false;
597 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
598 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
599 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
600 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
601 vDecSample->WaitForEOS();
602 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
603 }
604
605 /**
606 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0300
607 * @tc.name : surface API time test
608 * @tc.desc : perf test
609 */
610 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0300, TestSize.Level3)
611 {
612 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
613 vDecSample->INP_DIR = INP_DIR_1080_60;
614 vDecSample->OUT_DIR = "/data/test/media/1920_1080_60_out.rgba";
615 vDecSample->SF_OUTPUT = true;
616 vDecSample->DEFAULT_WIDTH = 1920;
617 vDecSample->DEFAULT_HEIGHT = 1080;
618 vDecSample->DEFAULT_FRAME_RATE = 60;
619 vDecSample->sleepOnFPS = false;
620 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
621 vDecSample->WaitForEOS();
622 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
623 }
624
625 /**
626 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0400
627 * @tc.name : create 1 decoder(1920*1080 60fps)+2 decoder(1280*720 60fps)
628 * @tc.desc : perf test
629 */
630 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0400, TestSize.Level3)
631 {
632 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
633 vDecSample->INP_DIR = INP_DIR_1080_60;
634 vDecSample->SF_OUTPUT = false;
635 vDecSample->DEFAULT_WIDTH = 1920;
636 vDecSample->DEFAULT_HEIGHT = 1080;
637 vDecSample->DEFAULT_FRAME_RATE = 60;
638 vDecSample->sleepOnFPS = false;
639 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
640 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
641 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
642 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
643
644 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
645 vDecSample1->INP_DIR = INP_DIR_720_60;
646 vDecSample1->SF_OUTPUT = false;
647 vDecSample1->DEFAULT_WIDTH = 1280;
648 vDecSample1->DEFAULT_HEIGHT = 720;
649 vDecSample1->DEFAULT_FRAME_RATE = 60;
650 vDecSample1->sleepOnFPS = true;
651 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
652 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
653 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
654 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
655
656 shared_ptr<VDecNdkSample> vDecSample2 = make_shared<VDecNdkSample>();
657 vDecSample2->SF_OUTPUT = false;
658 vDecSample2->INP_DIR = INP_DIR_720_30;
659 vDecSample2->DEFAULT_WIDTH = 1280;
660 vDecSample2->DEFAULT_HEIGHT = 720;
661 vDecSample2->DEFAULT_FRAME_RATE = 30;
662 vDecSample2->sleepOnFPS = true;
663 ASSERT_EQ(AV_ERR_OK, vDecSample2->CreateVideoDecoder(g_codecName));
664 ASSERT_EQ(AV_ERR_OK, vDecSample2->ConfigureVideoDecoder());
665 ASSERT_EQ(AV_ERR_OK, vDecSample2->SetVideoDecoderCallback());
666 ASSERT_EQ(AV_ERR_OK, vDecSample2->StartVideoDecoder());
667
668 vDecSample->WaitForEOS();
669 vDecSample1->WaitForEOS();
670 vDecSample2->WaitForEOS();
671 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
672 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
673 ASSERT_EQ(AV_ERR_OK, vDecSample2->errCount);
674 }
675
676 /**
677 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0500
678 * @tc.name : decode YUV time 1280*720 30fps 10M
679 * @tc.desc : perf test
680 */
681 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0500, TestSize.Level3)
682 {
683 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
684 vDecSample->SF_OUTPUT = false;
685 vDecSample->INP_DIR = INP_DIR_720_30;
686 vDecSample->DEFAULT_WIDTH = 1280;
687 vDecSample->DEFAULT_HEIGHT = 720;
688 vDecSample->DEFAULT_FRAME_RATE = 30;
689 vDecSample->sleepOnFPS = false;
690 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
691 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
692 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
693 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
694 vDecSample->WaitForEOS();
695 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
696 }
697
698 /**
699 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0600
700 * @tc.name : decode Surface time 1280*720 30fps 10M
701 * @tc.desc : perf test
702 */
703 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0600, TestSize.Level3)
704 {
705 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
706 vDecSample->INP_DIR = INP_DIR_720_30;
707 vDecSample->SF_OUTPUT = true;
708 vDecSample->DEFAULT_WIDTH = 1280;
709 vDecSample->DEFAULT_HEIGHT = 720;
710 vDecSample->DEFAULT_FRAME_RATE = 30;
711 vDecSample->sleepOnFPS = false;
712 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
713 vDecSample->WaitForEOS();
714 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
715 }
716
717 /**
718 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0700
719 * @tc.name : decode YUV time 1280*720 60fps 10M
720 * @tc.desc : perf test
721 */
722 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0700, TestSize.Level3)
723 {
724 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
725 vDecSample->INP_DIR = INP_DIR_720_60;
726 vDecSample->SF_OUTPUT = false;
727 vDecSample->DEFAULT_WIDTH = 1280;
728 vDecSample->DEFAULT_HEIGHT = 720;
729 vDecSample->DEFAULT_FRAME_RATE = 60;
730 vDecSample->sleepOnFPS = false;
731 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
732 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
733 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
734 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
735 vDecSample->WaitForEOS();
736 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
737 }
738
739 /**
740 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0800
741 * @tc.name : decode Surface time 1280*720 60fps 10M
742 * @tc.desc : perf test
743 */
744 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0800, TestSize.Level3)
745 {
746 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
747 vDecSample->INP_DIR = INP_DIR_720_60;
748 vDecSample->SF_OUTPUT = true;
749 vDecSample->DEFAULT_WIDTH = 1280;
750 vDecSample->DEFAULT_HEIGHT = 720;
751 vDecSample->DEFAULT_FRAME_RATE = 60;
752 vDecSample->sleepOnFPS = false;
753 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
754 vDecSample->WaitForEOS();
755 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
756 }
757
758 /**
759 * @tc.number : VIDEO_HWDEC_PERFORMANCE_0900
760 * @tc.name : decode YUV time 1920*1080 30fps 20M
761 * @tc.desc : perf test
762 */
763 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_0900, TestSize.Level3)
764 {
765 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
766 vDecSample->INP_DIR = INP_DIR_1080_30;
767 vDecSample->SF_OUTPUT = false;
768 vDecSample->DEFAULT_WIDTH = 1920;
769 vDecSample->DEFAULT_HEIGHT = 1080;
770 vDecSample->DEFAULT_FRAME_RATE = 30;
771 vDecSample->sleepOnFPS = false;
772 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
773 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
774 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
775 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
776 vDecSample->WaitForEOS();
777 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
778 }
779
780 /**
781 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1000
782 * @tc.name : decode Surface time 1920*1080 30fps 20M
783 * @tc.desc : perf test
784 */
785 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1000, TestSize.Level3)
786 {
787 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
788 vDecSample->INP_DIR = INP_DIR_1080_30;
789 vDecSample->SF_OUTPUT = true;
790 vDecSample->DEFAULT_WIDTH = 1920;
791 vDecSample->DEFAULT_HEIGHT = 1080;
792 vDecSample->DEFAULT_FRAME_RATE = 30;
793 vDecSample->sleepOnFPS = false;
794 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
795 vDecSample->WaitForEOS();
796 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
797 }
798
799 /**
800 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1100
801 * @tc.name : decode YUV time 1920*1080 60fps 20M
802 * @tc.desc : perf test
803 */
804 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1100, TestSize.Level3)
805 {
806 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
807 vDecSample->INP_DIR = INP_DIR_1080_60;
808 vDecSample->SF_OUTPUT = false;
809 vDecSample->DEFAULT_WIDTH = 1920;
810 vDecSample->DEFAULT_HEIGHT = 1080;
811 vDecSample->DEFAULT_FRAME_RATE = 60;
812 vDecSample->sleepOnFPS = false;
813 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
814 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
815 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
816 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
817 vDecSample->WaitForEOS();
818 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
819 }
820
821 /**
822 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1200
823 * @tc.name : decode Surface time 1920*1080 60fps 20M
824 * @tc.desc : perf test
825 */
826 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1200, TestSize.Level3)
827 {
828 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
829 vDecSample->INP_DIR = INP_DIR_1080_60;
830 vDecSample->SF_OUTPUT = true;
831 vDecSample->DEFAULT_WIDTH = 1920;
832 vDecSample->DEFAULT_HEIGHT = 1080;
833 vDecSample->DEFAULT_FRAME_RATE = 60;
834 vDecSample->sleepOnFPS = false;
835 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
836 vDecSample->WaitForEOS();
837 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
838 }
839
840 /**
841 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1300
842 * @tc.name : decode YUV time 3840*2160 30fps 50M
843 * @tc.desc : perf test
844 */
845 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1300, TestSize.Level3)
846 {
847 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
848 vDecSample->INP_DIR = INP_DIR_2160_30;
849 vDecSample->SF_OUTPUT = false;
850 vDecSample->DEFAULT_WIDTH = 3840;
851 vDecSample->DEFAULT_HEIGHT = 2160;
852 vDecSample->DEFAULT_FRAME_RATE = 30;
853 vDecSample->sleepOnFPS = true;
854 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
855 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
856 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
857 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
858 vDecSample->WaitForEOS();
859 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
860 }
861
862 /**
863 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1400
864 * @tc.name : decode Surface time 3840*2160 30fps 50M
865 * @tc.desc : perf test
866 */
867 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1400, TestSize.Level3)
868 {
869 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
870 vDecSample->INP_DIR = INP_DIR_2160_30;
871 vDecSample->SF_OUTPUT = true;
872 vDecSample->DEFAULT_WIDTH = 3840;
873 vDecSample->DEFAULT_HEIGHT = 2160;
874 vDecSample->DEFAULT_FRAME_RATE = 30;
875 vDecSample->sleepOnFPS = false;
876 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
877 vDecSample->WaitForEOS();
878 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
879 }
880
881 /**
882 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1500
883 * @tc.name : decode YUV time 3840*2160 60fps 50M
884 * @tc.desc : perf test
885 */
886 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1500, TestSize.Level3)
887 {
888 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
889 vDecSample->INP_DIR = INP_DIR_2160_60;
890 vDecSample->SF_OUTPUT = false;
891 vDecSample->DEFAULT_WIDTH = 3840;
892 vDecSample->DEFAULT_HEIGHT = 2160;
893 vDecSample->DEFAULT_FRAME_RATE = 60;
894 vDecSample->sleepOnFPS = false;
895 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
896 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
897 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
898 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
899 vDecSample->WaitForEOS();
900 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
901 }
902
903 /**
904 * @tc.number : VIDEO_HWDEC_PERFORMANCE_1600
905 * @tc.name : decode Surface time 3840*2160 60fps 50M
906 * @tc.desc : perf test
907 */
908 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_1600, TestSize.Level3)
909 {
910 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
911 vDecSample->INP_DIR = INP_DIR_2160_60;
912 vDecSample->SF_OUTPUT = true;
913 vDecSample->DEFAULT_WIDTH = 3840;
914 vDecSample->DEFAULT_HEIGHT = 2160;
915 vDecSample->DEFAULT_FRAME_RATE = 60;
916 vDecSample->sleepOnFPS = false;
917 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
918 vDecSample->WaitForEOS();
919 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
920 }
921
922 /**
923 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_0500
924 * @tc.name : decode YUV time 1280*720 30fps 10M
925 * @tc.desc : perf test
926 */
927 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_0500, TestSize.Level3)
928 {
929 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
930 vDecSample->INP_DIR = INP_DIR_720_30_1;
931 vDecSample->SF_OUTPUT = false;
932 vDecSample->DEFAULT_WIDTH = 1280;
933 vDecSample->DEFAULT_HEIGHT = 720;
934 vDecSample->DEFAULT_FRAME_RATE = 30;
935 vDecSample->sleepOnFPS = false;
936 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
937 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
938 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
939 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
940
941 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
942 vDecSample1->INP_DIR = INP_DIR_720_30;
943 vDecSample1->SF_OUTPUT = false;
944 vDecSample1->DEFAULT_WIDTH = 1280;
945 vDecSample1->DEFAULT_HEIGHT = 720;
946 vDecSample1->DEFAULT_FRAME_RATE = 30;
947 vDecSample1->sleepOnFPS = true;
948 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
949 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
950 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
951 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
952
953 vDecSample->WaitForEOS();
954 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
955 vDecSample1->WaitForEOS();
956 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
957 }
958
959 /**
960 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_0600
961 * @tc.name : decode Surface time 1280*720 30fps 10M
962 * @tc.desc : perf test
963 */
964 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_0600, TestSize.Level3)
965 {
966 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
967 vDecSample->INP_DIR = INP_DIR_720_30_1;
968 vDecSample->SF_OUTPUT = true;
969 vDecSample->DEFAULT_WIDTH = 1280;
970 vDecSample->DEFAULT_HEIGHT = 720;
971 vDecSample->DEFAULT_FRAME_RATE = 30;
972 vDecSample->sleepOnFPS = false;
973 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
974
975 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
976 vDecSample1->INP_DIR = INP_DIR_720_30;
977 vDecSample1->SF_OUTPUT = true;
978 vDecSample1->DEFAULT_WIDTH = 1280;
979 vDecSample1->DEFAULT_HEIGHT = 720;
980 vDecSample1->DEFAULT_FRAME_RATE = 30;
981 vDecSample1->sleepOnFPS = true;
982 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName));
983
984 vDecSample->WaitForEOS();
985 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
986 vDecSample1->WaitForEOS();
987 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
988 }
989
990 /**
991 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_0700
992 * @tc.name : decode YUV time 1280*720 60fps 10M
993 * @tc.desc : perf test
994 */
995 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_0700, TestSize.Level3)
996 {
997 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
998 vDecSample->INP_DIR = INP_DIR_720_60_1;
999 vDecSample->SF_OUTPUT = false;
1000 vDecSample->DEFAULT_WIDTH = 1280;
1001 vDecSample->DEFAULT_HEIGHT = 720;
1002 vDecSample->DEFAULT_FRAME_RATE = 60;
1003 vDecSample->sleepOnFPS = false;
1004 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1005 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1006 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1007 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1008
1009 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1010 vDecSample1->INP_DIR = INP_DIR_720_60;
1011 vDecSample1->SF_OUTPUT = false;
1012 vDecSample1->DEFAULT_WIDTH = 1280;
1013 vDecSample1->DEFAULT_HEIGHT = 720;
1014 vDecSample1->DEFAULT_FRAME_RATE = 60;
1015 vDecSample1->sleepOnFPS = true;
1016 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
1017 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
1018 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
1019 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
1020
1021 vDecSample->WaitForEOS();
1022 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1023 vDecSample1->WaitForEOS();
1024 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1025 }
1026
1027 /**
1028 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_0800
1029 * @tc.name : decode Surface time 1280*720 60fps 10M
1030 * @tc.desc : perf test
1031 */
1032 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_0800, TestSize.Level3)
1033 {
1034 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1035 vDecSample->INP_DIR = INP_DIR_720_60;
1036 vDecSample->SF_OUTPUT = true;
1037 vDecSample->DEFAULT_WIDTH = 1280;
1038 vDecSample->DEFAULT_HEIGHT = 720;
1039 vDecSample->DEFAULT_FRAME_RATE = 60;
1040 vDecSample->sleepOnFPS = false;
1041 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
1042
1043 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1044 vDecSample1->INP_DIR = INP_DIR_720_60_1;
1045 vDecSample1->SF_OUTPUT = true;
1046 vDecSample1->DEFAULT_WIDTH = 1280;
1047 vDecSample1->DEFAULT_HEIGHT = 720;
1048 vDecSample1->DEFAULT_FRAME_RATE = 60;
1049 vDecSample1->sleepOnFPS = true;
1050 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName));
1051
1052 vDecSample->WaitForEOS();
1053 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1054 vDecSample1->WaitForEOS();
1055 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1056 }
1057
1058 /**
1059 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_0900
1060 * @tc.name : decode YUV time 1920*1080 30fps 20M
1061 * @tc.desc : perf test
1062 */
1063 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_0900, TestSize.Level3)
1064 {
1065 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1066 vDecSample->INP_DIR = INP_DIR_1080_30_1;
1067 vDecSample->SF_OUTPUT = false;
1068 vDecSample->DEFAULT_WIDTH = 1920;
1069 vDecSample->DEFAULT_HEIGHT = 1080;
1070 vDecSample->DEFAULT_FRAME_RATE = 30;
1071 vDecSample->sleepOnFPS = false;
1072 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1073 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1074 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1075 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1076
1077 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1078 vDecSample1->INP_DIR = INP_DIR_1080_30;
1079 vDecSample1->SF_OUTPUT = false;
1080 vDecSample1->DEFAULT_WIDTH = 1920;
1081 vDecSample1->DEFAULT_HEIGHT = 1080;
1082 vDecSample1->DEFAULT_FRAME_RATE = 30;
1083 vDecSample1->sleepOnFPS = true;
1084 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
1085 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
1086 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
1087 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
1088
1089 vDecSample->WaitForEOS();
1090 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1091 vDecSample1->WaitForEOS();
1092 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1093 }
1094
1095 /**
1096 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1000
1097 * @tc.name : decode Surface time 1920*1080 30fps 20M
1098 * @tc.desc : perf test
1099 */
1100 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1000, TestSize.Level3)
1101 {
1102 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1103 vDecSample->INP_DIR = INP_DIR_1080_30;
1104 vDecSample->SF_OUTPUT = true;
1105 vDecSample->DEFAULT_WIDTH = 1920;
1106 vDecSample->DEFAULT_HEIGHT = 1080;
1107 vDecSample->DEFAULT_FRAME_RATE = 30;
1108 vDecSample->sleepOnFPS = false;
1109 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
1110
1111 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1112 vDecSample1->INP_DIR = INP_DIR_1080_30_1;
1113 vDecSample1->SF_OUTPUT = true;
1114 vDecSample1->DEFAULT_WIDTH = 1920;
1115 vDecSample1->DEFAULT_HEIGHT = 1080;
1116 vDecSample1->DEFAULT_FRAME_RATE = 30;
1117 vDecSample1->sleepOnFPS = true;
1118 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName));
1119
1120 vDecSample->WaitForEOS();
1121 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1122 vDecSample1->WaitForEOS();
1123 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1124 }
1125
1126 /**
1127 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1100
1128 * @tc.name : decode YUV time 1920*1080 60fps 20M
1129 * @tc.desc : perf test
1130 */
1131 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1100, TestSize.Level3)
1132 {
1133 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1134 vDecSample->INP_DIR = INP_DIR_1080_60_1;
1135 vDecSample->SF_OUTPUT = false;
1136 vDecSample->DEFAULT_WIDTH = 1920;
1137 vDecSample->DEFAULT_HEIGHT = 1080;
1138 vDecSample->DEFAULT_FRAME_RATE = 60;
1139 vDecSample->sleepOnFPS = false;
1140 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1141 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1142 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1143 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1144
1145 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1146 vDecSample1->INP_DIR = INP_DIR_1080_60;
1147 vDecSample1->SF_OUTPUT = false;
1148 vDecSample1->DEFAULT_WIDTH = 1920;
1149 vDecSample1->DEFAULT_HEIGHT = 1080;
1150 vDecSample1->DEFAULT_FRAME_RATE = 60;
1151 vDecSample1->sleepOnFPS = true;
1152 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
1153 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
1154 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
1155 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
1156
1157 vDecSample->WaitForEOS();
1158 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1159 vDecSample1->WaitForEOS();
1160 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1161 }
1162
1163 /**
1164 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1200
1165 * @tc.name : decode Surface time 1920*1080 60fps 20M
1166 * @tc.desc : perf test
1167 */
1168 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1200, TestSize.Level3)
1169 {
1170 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1171 vDecSample->INP_DIR = INP_DIR_1080_60;
1172 vDecSample->SF_OUTPUT = true;
1173 vDecSample->DEFAULT_WIDTH = 1920;
1174 vDecSample->DEFAULT_HEIGHT = 1080;
1175 vDecSample->DEFAULT_FRAME_RATE = 60;
1176 vDecSample->sleepOnFPS = false;
1177 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
1178
1179 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1180 vDecSample1->INP_DIR = INP_DIR_1080_60_1;
1181 vDecSample1->SF_OUTPUT = true;
1182 vDecSample1->DEFAULT_WIDTH = 1920;
1183 vDecSample1->DEFAULT_HEIGHT = 1080;
1184 vDecSample1->DEFAULT_FRAME_RATE = 60;
1185 vDecSample1->sleepOnFPS = true;
1186 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName));
1187
1188 vDecSample->WaitForEOS();
1189 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1190 vDecSample1->WaitForEOS();
1191 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1192 }
1193
1194 /**
1195 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1300
1196 * @tc.name : decode YUV time 3840*2160 30fps 50M
1197 * @tc.desc : perf test
1198 */
1199 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1300, TestSize.Level3)
1200 {
1201 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1202 vDecSample->INP_DIR = INP_DIR_2160_30_1;
1203 vDecSample->SF_OUTPUT = false;
1204 vDecSample->DEFAULT_WIDTH = 3840;
1205 vDecSample->DEFAULT_HEIGHT = 2160;
1206 vDecSample->DEFAULT_FRAME_RATE = 30;
1207 vDecSample->sleepOnFPS = false;
1208 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1209 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1210 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1211 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1212
1213 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1214 vDecSample1->INP_DIR = INP_DIR_2160_30;
1215 vDecSample1->SF_OUTPUT = false;
1216 vDecSample1->DEFAULT_WIDTH = 3840;
1217 vDecSample1->DEFAULT_HEIGHT = 2160;
1218 vDecSample1->DEFAULT_FRAME_RATE = 30;
1219 vDecSample1->sleepOnFPS = true;
1220 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
1221 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
1222 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
1223 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
1224
1225 vDecSample->WaitForEOS();
1226 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1227 vDecSample1->WaitForEOS();
1228 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1229 }
1230
1231 /**
1232 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1400
1233 * @tc.name : decode Surface time 3840*2160 30fps 50M
1234 * @tc.desc : perf test
1235 */
1236 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1400, TestSize.Level3)
1237 {
1238 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1239 vDecSample->INP_DIR = INP_DIR_2160_30;
1240 vDecSample->SF_OUTPUT = true;
1241 vDecSample->DEFAULT_WIDTH = 3840;
1242 vDecSample->DEFAULT_HEIGHT = 2160;
1243 vDecSample->DEFAULT_FRAME_RATE = 30;
1244 vDecSample->sleepOnFPS = false;
1245 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
1246
1247 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1248 vDecSample1->INP_DIR = INP_DIR_2160_30_1;
1249 vDecSample1->SF_OUTPUT = true;
1250 vDecSample1->DEFAULT_WIDTH = 3840;
1251 vDecSample1->DEFAULT_HEIGHT = 2160;
1252 vDecSample1->DEFAULT_FRAME_RATE = 30;
1253 vDecSample1->sleepOnFPS = true;
1254 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName));
1255
1256 vDecSample->WaitForEOS();
1257 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1258 vDecSample1->WaitForEOS();
1259 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1260 }
1261
1262 /**
1263 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1500
1264 * @tc.name : decode YUV time 3840*2160 60fps 50M
1265 * @tc.desc : perf test
1266 */
1267 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1500, TestSize.Level3)
1268 {
1269 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1270 vDecSample->INP_DIR = INP_DIR_2160_60_1;
1271 vDecSample->SF_OUTPUT = false;
1272 vDecSample->DEFAULT_WIDTH = 3840;
1273 vDecSample->DEFAULT_HEIGHT = 2160;
1274 vDecSample->DEFAULT_FRAME_RATE = 60;
1275 vDecSample->sleepOnFPS = false;
1276 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1277 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1278 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1279 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1280
1281 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1282 vDecSample1->INP_DIR = INP_DIR_2160_60;
1283 vDecSample1->SF_OUTPUT = false;
1284 vDecSample1->DEFAULT_WIDTH = 3840;
1285 vDecSample1->DEFAULT_HEIGHT = 2160;
1286 vDecSample1->DEFAULT_FRAME_RATE = 60;
1287 vDecSample1->sleepOnFPS = true;
1288 ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
1289 ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
1290 ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
1291 ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
1292
1293 vDecSample->WaitForEOS();
1294 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1295 vDecSample1->WaitForEOS();
1296 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1297 }
1298
1299 /**
1300 * @tc.number : VIDEO_HWDEC_PERFORMANCE_MORE_1600
1301 * @tc.name : decode Surface time 3840*2160 60fps 50M
1302 * @tc.desc : perf test
1303 */
1304 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_PERFORMANCE_MORE_1600, TestSize.Level3)
1305 {
1306 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1307 vDecSample->INP_DIR = INP_DIR_2160_60_1;
1308 vDecSample->SF_OUTPUT = true;
1309 vDecSample->DEFAULT_WIDTH = 3840;
1310 vDecSample->DEFAULT_HEIGHT = 2160;
1311 vDecSample->DEFAULT_FRAME_RATE = 60;
1312 vDecSample->sleepOnFPS = false;
1313 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
1314
1315 shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
1316 vDecSample1->INP_DIR = INP_DIR_2160_60;
1317 vDecSample1->SF_OUTPUT = true;
1318 vDecSample1->DEFAULT_WIDTH = 3840;
1319 vDecSample1->DEFAULT_HEIGHT = 2160;
1320 vDecSample1->DEFAULT_FRAME_RATE = 60;
1321 vDecSample1->sleepOnFPS = true;
1322 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecName));
1323
1324 vDecSample->WaitForEOS();
1325 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1326 vDecSample1->WaitForEOS();
1327 ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
1328 }
1329
1330 /**
1331 * @tc.number : VIDEO_HWDEC_MULTIINSTANCE_0100
1332 * @tc.name : create 16 decoder (320*240)
1333 * @tc.desc : function test
1334 */
1335 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_MULTIINSTANCE_0100, TestSize.Level3)
1336 {
1337 vector<shared_ptr<VDecNdkSample>> decVec;
1338 for (int i = 0; i < MAX_THREAD; i++) {
1339 auto vDecSample = make_shared<VDecNdkSample>();
1340 decVec.push_back(vDecSample);
1341 vDecSample->INP_DIR = INP_DIR_1080_30;
1342 vDecSample->DEFAULT_WIDTH = 1920;
1343 vDecSample->DEFAULT_HEIGHT = 1080;
1344 vDecSample->DEFAULT_FRAME_RATE = 30;
1345 vDecSample->SF_OUTPUT = false;
1346 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1347 cout << "count=" << i << endl;
1348 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1349 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1350 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
1351 }
1352 }
1353 /**
1354 * @tc.number : VIDEO_HWDEC_MULTIINSTANCE_0100
1355 * @tc.name : create 17 decoder
1356 * @tc.desc : function test
1357 */
1358 HWTEST_F(HwdecPerfNdkTest, VIDEO_HWDEC_MULTIINSTANCE_0200, TestSize.Level3)
1359 {
1360 vector<shared_ptr<VDecNdkSample>> decVec;
1361 for (int i = 0; i < MAX_THREAD + 1; i++) {
1362 auto vDecSample = make_shared<VDecNdkSample>();
1363 decVec.push_back(vDecSample);
1364 vDecSample->INP_DIR = INP_DIR_1080_30;
1365 vDecSample->DEFAULT_WIDTH = 1920;
1366 vDecSample->DEFAULT_HEIGHT = 1080;
1367 vDecSample->DEFAULT_FRAME_RATE = 30;
1368 vDecSample->SF_OUTPUT = false;
1369 if (i < MAX_THREAD) {
1370 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1371 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1372 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1373 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
1374 } else {
1375 ASSERT_EQ(AV_ERR_UNKNOWN, vDecSample->CreateVideoDecoder(g_codecName));
1376 }
1377 cout << "count=" << i << endl;
1378 }
1379 }
1380 } // namespace