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