1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <string>
16 #include "gtest/gtest.h"
17 #include "native_avcodec_videodecoder.h"
18 #include "native_averrors.h"
19 #include "videodec_ndk_sample.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22 #include "native_avcapability.h"
23
24 #define MAX_THREAD 16
25
26 using namespace std;
27 using namespace OHOS;
28 using namespace OHOS::Media;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Media {
33 class HwdecFuncNdkTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 void InputFunc();
40 void OutputFunc();
41 void Release();
42 int32_t Stop();
43
44 protected:
45 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
46 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
47 };
48 } // namespace Media
49 } // namespace OHOS
50
51 namespace {
52 static OH_AVCapability *cap = nullptr;
53 static OH_AVCapability *cap_hevc = nullptr;
54 static OH_AVRange heightRange;
55 static OH_AVRange widthRange;
56 static OH_AVErrCode ret = AV_ERR_OK;
57 static string g_codecName = "";
58 static string g_codecNameHEVC = "";
59 constexpr int32_t DEFAULT_WIDTH = 1920;
60 constexpr int32_t DEFAULT_HEIGHT = 1080;
61 constexpr int32_t UHD_RESOLUTION[2] = {3840, 2160};
62 constexpr int32_t HD_RESOLUTION[2] = {1104, 622};
63 } // namespace
64
SetUpTestCase()65 void HwdecFuncNdkTest::SetUpTestCase()
66 {
67 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
68 g_codecName = OH_AVCapability_GetName(cap);
69 cout << "codecname: " << g_codecName << endl;
70 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
71 g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
72 cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
73 ret = OH_AVCapability_GetVideoHeightRange(cap, &heightRange);
74 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
75 ret = OH_AVCapability_GetVideoWidthRangeForHeight(cap, heightRange.maxVal, &widthRange);
76 cout << "minval=" << widthRange.minVal << " maxval=" << widthRange.maxVal << endl;
77 }
TearDownTestCase()78 void HwdecFuncNdkTest::TearDownTestCase() {}
SetUp()79 void HwdecFuncNdkTest::SetUp() {}
TearDown()80 void HwdecFuncNdkTest::TearDown() {}
81
82 namespace {
83 /**
84 * @tc.number : VIDEO_HWDEC_FUNCTION_0200
85 * @tc.name : create nonexist decoder
86 * @tc.desc : function test
87 */
88 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0200, TestSize.Level1)
89 {
90 OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
91 ASSERT_EQ(nullptr, vdec_);
92 }
93
94 /**
95 * @tc.number : VIDEO_HWDEC_FUNCTION_0300
96 * @tc.name : test h264 asyn decode buffer
97 * @tc.desc : function test
98 */
99 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0300, TestSize.Level0)
100 {
101 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
102 vDecSample->INP_DIR = INP_DIR_1080_30;
103 vDecSample->DEFAULT_WIDTH = 1920;
104 vDecSample->DEFAULT_HEIGHT = 1080;
105 vDecSample->DEFAULT_FRAME_RATE = 30;
106 vDecSample->SF_OUTPUT = false;
107 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
108 vDecSample->WaitForEOS();
109 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
110 }
111
112 /**
113 * @tc.number : VIDEO_HWDEC_FUNCTION_0400
114 * @tc.name : test h264 asyn decode surface
115 * @tc.desc : function test
116 */
117 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0400, TestSize.Level0)
118 {
119 VDecNdkSample *vDecSample = new VDecNdkSample();
120 vDecSample->INP_DIR = INP_DIR_1080_30;
121 vDecSample->SF_OUTPUT = true;
122 vDecSample->DEFAULT_WIDTH = 1920;
123 vDecSample->DEFAULT_HEIGHT = 1080;
124 vDecSample->DEFAULT_FRAME_RATE = 30;
125 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
126 vDecSample->WaitForEOS();
127 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
128 delete vDecSample;
129 vDecSample = nullptr;
130 }
131
132 /**
133 * @tc.number : VIDEO_HWDEC_FUNCTION_0700
134 * @tc.name : test set EOS when last frame
135 * @tc.desc : function test
136 */
137 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0700, TestSize.Level1)
138 {
139 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
140 vDecSample->INP_DIR = INP_DIR_1080_30;
141 vDecSample->DEFAULT_WIDTH = 1920;
142 vDecSample->DEFAULT_HEIGHT = 1080;
143 vDecSample->DEFAULT_FRAME_RATE = 30;
144 vDecSample->SF_OUTPUT = false;
145 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
146 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
147 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
148 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
149 vDecSample->WaitForEOS();
150 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
151 }
152
153 /**
154 * @tc.number : VIDEO_HWDEC_FUNCTION_0800
155 * @tc.name : test set EOS before last frame then stop
156 * @tc.desc : function test
157 */
158 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0800, TestSize.Level1)
159 {
160 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
161 vDecSample->INP_DIR = INP_DIR_1080_30;
162 vDecSample->DEFAULT_WIDTH = 1920;
163 vDecSample->DEFAULT_HEIGHT = 1080;
164 vDecSample->DEFAULT_FRAME_RATE = 30;
165 vDecSample->SF_OUTPUT = false;
166 vDecSample->BEFORE_EOS_INPUT = true;
167 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
168 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
169 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
170 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
171 vDecSample->WaitForEOS();
172 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
173 }
174
175 /**
176 * @tc.number : VIDEO_HWDEC_FUNCTION_0900
177 * @tc.name : test set EOS before last frame then input frames
178 * @tc.desc : function test
179 */
180 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0900, TestSize.Level1)
181 {
182 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
183 vDecSample->INP_DIR = INP_DIR_1080_30;
184 vDecSample->DEFAULT_WIDTH = 1920;
185 vDecSample->DEFAULT_HEIGHT = 1080;
186 vDecSample->DEFAULT_FRAME_RATE = 30;
187 vDecSample->SF_OUTPUT = false;
188 vDecSample->BEFORE_EOS_INPUT_INPUT = true;
189 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
190 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
191 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
192 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
193 vDecSample->WaitForEOS();
194 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
195 }
196
197 /**
198 * @tc.number : VIDEO_HWDEC_FUNCTION_1000
199 * @tc.name : test reconfigure for new file with one decoder
200 * @tc.desc : function test
201 */
202 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1000, TestSize.Level1)
203 {
204 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
205 vDecSample->INP_DIR = INP_DIR_1080_30;
206 vDecSample->DEFAULT_WIDTH = 1920;
207 vDecSample->DEFAULT_HEIGHT = 1080;
208 vDecSample->DEFAULT_FRAME_RATE = 30;
209 vDecSample->SF_OUTPUT = false;
210 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
211 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
212 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
213 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
214 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
215 vDecSample->WaitForEOS();
216 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
217 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
218 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
219 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
220 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
221 vDecSample->WaitForEOS();
222 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
223 }
224
225 /**
226 * @tc.number : VIDEO_HWDEC_FUNCTION_1100
227 * @tc.name : test reconfigure for new file with the recreated decoder
228 * @tc.desc : function test
229 */
230 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1100, TestSize.Level1)
231 {
232 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
233 vDecSample->INP_DIR = INP_DIR_1080_30;
234 vDecSample->DEFAULT_WIDTH = 1920;
235 vDecSample->DEFAULT_HEIGHT = 1080;
236 vDecSample->DEFAULT_FRAME_RATE = 30;
237 vDecSample->SF_OUTPUT = false;
238 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
239 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
240 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
241 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
242 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
243 vDecSample->WaitForEOS();
244 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
245 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
246 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
247 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
248 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
249 vDecSample->WaitForEOS();
250 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
251 }
252
253 /**
254 * @tc.number : VIDEO_HWDEC_FUNCTION_1200
255 * @tc.name : repeat start and stop 5 times before EOS
256 * @tc.desc : function test
257 */
258 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1200, TestSize.Level2)
259 {
260 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
261 vDecSample->INP_DIR = INP_DIR_1080_30;
262 vDecSample->DEFAULT_WIDTH = 1920;
263 vDecSample->DEFAULT_HEIGHT = 1080;
264 vDecSample->DEFAULT_FRAME_RATE = 30;
265 vDecSample->SF_OUTPUT = false;
266 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
267 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
268 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
269 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
270 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
271 vDecSample->WaitForEOS();
272 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
273 }
274
275 /**
276 * @tc.number : VIDEO_HWDEC_FUNCTION_1300
277 * @tc.name : repeat start and flush 5 times before EOS
278 * @tc.desc : function test
279 */
280 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1300, TestSize.Level2)
281 {
282 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
283 vDecSample->INP_DIR = INP_DIR_1080_30;
284 vDecSample->DEFAULT_WIDTH = 1920;
285 vDecSample->DEFAULT_HEIGHT = 1080;
286 vDecSample->DEFAULT_FRAME_RATE = 30;
287 vDecSample->SF_OUTPUT = false;
288 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
289 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
290 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
291 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
292 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
293 vDecSample->WaitForEOS();
294 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
295 }
296
297 /**
298 * @tc.number : VIDEO_HWDEC_FUNCTION_1400
299 * @tc.name : set larger width and height
300 * @tc.desc : function test
301 */
302 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1400, TestSize.Level2)
303 {
304 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
305 vDecSample->INP_DIR = INP_DIR_720_30;
306 vDecSample->DEFAULT_WIDTH = 1920;
307 vDecSample->DEFAULT_HEIGHT = 1080;
308 vDecSample->DEFAULT_FRAME_RATE = 30;
309 vDecSample->SF_OUTPUT = false;
310 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
311 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
312 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
313 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
314 vDecSample->WaitForEOS();
315 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
316 }
317
318 /**
319 * @tc.number : VIDEO_HWDEC_FUNCTION_1600
320 * @tc.name : 265 decode
321 * @tc.desc : function test
322 */
323 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1600, TestSize.Level2)
324 {
325 if (cap_hevc) {
326 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
327 vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
328 vDecSample->DEFAULT_WIDTH = 1920;
329 vDecSample->DEFAULT_HEIGHT = 1080;
330 vDecSample->DEFAULT_FRAME_RATE = 30;
331 vDecSample->SF_OUTPUT = false;
332 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
333 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
334 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
335 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
336 vDecSample->WaitForEOS();
337 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
338 }
339 }
340
341 /**
342 * @tc.number : VIDEO_HWDEC_FUNCTION_1700
343 * @tc.name : resolution change
344 * @tc.desc : function test
345 */
346 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1700, TestSize.Level2)
347 {
348 if (g_codecName.find("hisi") != string::npos) {
349 auto vDecSample = make_shared<VDecNdkSample>();
350 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
351 vDecSample->DEFAULT_WIDTH = 1104;
352 vDecSample->DEFAULT_HEIGHT = 622;
353 vDecSample->DEFAULT_FRAME_RATE = 30;
354 vDecSample->SF_OUTPUT = 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 } else {
362 cout << "hardware encoder is rk,skip." << endl;
363 }
364 }
365 /**
366 * @tc.number : SURF_CHANGE_FUNC_001
367 * @tc.name : surf change in normal state
368 * @tc.desc : function test
369 */
370 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)
371 {
372 auto vDecSample = make_shared<VDecNdkSample>();
373 vDecSample->INP_DIR = INP_DIR_1080_30;
374 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
375 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
376 vDecSample->DEFAULT_FRAME_RATE = 30;
377 vDecSample->SF_OUTPUT = true;
378 vDecSample->autoSwitchSurface = true;
379 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
380 vDecSample->sleepOnFPS = true;
381 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
382 vDecSample->WaitForEOS();
383 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
384 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
385 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
386 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
387 }
388 /**
389 * @tc.number : SURF_CHANGE_FUNC_002
390 * @tc.name : surf change in flushed state
391 * @tc.desc : function test
392 */
393 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)
394 {
395 auto vDecSample = make_shared<VDecNdkSample>();
396 vDecSample->INP_DIR = INP_DIR_1080_30;
397 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
398 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
399 vDecSample->DEFAULT_FRAME_RATE = 30;
400 vDecSample->SF_OUTPUT = true;
401 vDecSample->autoSwitchSurface = true;
402 vDecSample->sleepOnFPS = true;
403 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
404 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
405 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
406 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
407 }
408 /**
409 * @tc.number : SURF_CHANGE_FUNC_003
410 * @tc.name : surf change in buffer mode
411 * @tc.desc : function test
412 */
413 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)
414 {
415 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
416 vDecSample->INP_DIR = INP_DIR_1080_30;
417 vDecSample->DEFAULT_WIDTH = 1920;
418 vDecSample->DEFAULT_HEIGHT = 1080;
419 vDecSample->DEFAULT_FRAME_RATE = 30;
420 vDecSample->SF_OUTPUT = false;
421 vDecSample->CreateSurface();
422 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
423 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
424 vDecSample->WaitForEOS();
425 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
426 }
427 /**
428 * @tc.number : SURF_CHANGE_FUNC_004
429 * @tc.name : repeat call setSurface fastly
430 * @tc.desc : function test
431 */
432 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)
433 {
434 auto vDecSample = make_shared<VDecNdkSample>();
435 vDecSample->INP_DIR = INP_DIR_1080_30;
436 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
437 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
438 vDecSample->DEFAULT_FRAME_RATE = 30;
439 vDecSample->SF_OUTPUT = true;
440 vDecSample->autoSwitchSurface = true;
441 vDecSample->sleepOnFPS = true;
442 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
443 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
444 vDecSample->WaitForEOS();
445 }
446
447 /**
448 * @tc.number : OUTPUT_DECS_FUNC_001
449 * @tc.name : get decode output descriptions h264
450 * @tc.desc : function test
451 */
452 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_001, TestSize.Level0)
453 {
454 auto vDecSample = make_shared<VDecNdkSample>();
455 vDecSample->INP_DIR = "/data/test/media/1920x1080.h264";
456 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
457 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
458 vDecSample->DEFAULT_FRAME_RATE = 30;
459 vDecSample->needCheckOutputDesc = true;
460 vDecSample->expectCropTop = 0;
461 vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
462 vDecSample->expectCropLeft = 0;
463 vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
464
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 * @tc.number : OUTPUT_DECS_FUNC_002
474 * @tc.name : get decode output descriptions h265
475 * @tc.desc : function test
476 */
477 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_002, TestSize.Level0)
478 {
479 if (cap_hevc) {
480 auto vDecSample = make_shared<VDecNdkSample>();
481 vDecSample->INP_DIR = "/data/test/media/1920x1080.h265";
482 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
483 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
484 vDecSample->DEFAULT_FRAME_RATE = 30;
485 vDecSample->needCheckOutputDesc = true;
486 vDecSample->expectCropTop = 0;
487 vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
488 vDecSample->expectCropLeft = 0;
489 vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
490
491 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
492 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
493 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
494 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
495 vDecSample->WaitForEOS();
496 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
497 }
498 }
499 /**
500 * @tc.number : OUTPUT_DECS_FUNC_003
501 * @tc.name : get decode output descriptions h264 ,4k
502 * @tc.desc : function test
503 */
504 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_003, TestSize.Level0)
505 {
506 if (cap) {
507 auto vDecSample = make_shared<VDecNdkSample>();
508 vDecSample->INP_DIR = "/data/test/media/3840x2160.h264";
509 if ((widthRange.maxVal>=UHD_RESOLUTION[0]) && (heightRange.maxVal>=UHD_RESOLUTION[1])) {
510 vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
511 vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
512 vDecSample->DEFAULT_FRAME_RATE = 30;
513 vDecSample->needCheckOutputDesc = true;
514 vDecSample->expectCropTop = 0;
515 vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
516 vDecSample->expectCropLeft = 0;
517 vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
518 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
519 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
520 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
521 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
522 vDecSample->WaitForEOS();
523 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
524 } else {
525 return;
526 }
527 }
528 }
529 /**
530 * @tc.number : OUTPUT_DECS_FUNC_004
531 * @tc.name : get decode output descriptions h265 ,4k
532 * @tc.desc : function test
533 */
534 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_004, TestSize.Level0)
535 {
536 if (cap_hevc) {
537 auto vDecSample = make_shared<VDecNdkSample>();
538 vDecSample->INP_DIR = "/data/test/media/3840x2160.h265";
539 vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
540 vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
541 vDecSample->DEFAULT_FRAME_RATE = 30;
542 vDecSample->needCheckOutputDesc = true;
543 vDecSample->expectCropTop = 0;
544 vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
545 vDecSample->expectCropLeft = 0;
546 vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
547
548 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
549 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
550 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
551 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
552 vDecSample->WaitForEOS();
553 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
554 }
555 }
556 /**
557 * @tc.number : OUTPUT_DECS_FUNC_005
558 * @tc.name : get decode output descriptions h264 ,crop size
559 * @tc.desc : function test
560 */
561 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_005, TestSize.Level0)
562 {
563 auto vDecSample = make_shared<VDecNdkSample>();
564 vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
565 vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
566 vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
567 vDecSample->DEFAULT_FRAME_RATE = 30;
568 vDecSample->needCheckOutputDesc = true;
569 vDecSample->expectCropTop = 0;
570 vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
571 vDecSample->expectCropLeft = 0;
572 vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
573
574 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
575 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
576 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
577 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
578 vDecSample->WaitForEOS();
579 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
580 }
581 /**
582 * @tc.number : OUTPUT_DECS_FUNC_006
583 * @tc.name : get decode output descriptions h265 ,crop size
584 * @tc.desc : function test
585 */
586 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_006, TestSize.Level0)
587 {
588 if (cap_hevc) {
589 auto vDecSample = make_shared<VDecNdkSample>();
590 vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
591 vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
592 vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
593 vDecSample->DEFAULT_FRAME_RATE = 30;
594 vDecSample->needCheckOutputDesc = true;
595 vDecSample->expectCropTop = 0;
596 vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
597 vDecSample->expectCropLeft = 0;
598 vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
599
600 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
601 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
602 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
603 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
604 vDecSample->WaitForEOS();
605 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
606 }
607 }
608 /**
609 * @tc.number : OUTPUT_DECS_FUNC_007
610 * @tc.name : get decode output descriptions h265 ,resolution change
611 * @tc.desc : function test
612 */
613 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_007, TestSize.Level0)
614 {
615 if ((g_codecName.find("hisi") != string::npos) && (cap)) {
616 auto vDecSample = make_shared<VDecNdkSample>();
617 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
618 vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
619 vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
620 vDecSample->DEFAULT_FRAME_RATE = 30;
621 vDecSample->isResChangeStream = true;
622 vDecSample->expectCropTop = 0;
623 vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
624 vDecSample->expectCropLeft = 0;
625 vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
626
627 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
628 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
629 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
630 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
631 vDecSample->WaitForEOS();
632 } else {
633 cout << "hardware encoder is rk,skip." << endl;
634 }
635 }
636 } // namespace