1 /*
2 * Copyright (C) 2025 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_sample.h"
20 #include "videodec_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24
25 #define MAX_THREAD 16
26
27 using namespace std;
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Media {
34 class HwdecFunc2NdkTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 void InputFunc();
41 void OutputFunc();
42 void Release();
43 int32_t Stop();
44
45 protected:
46 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
47 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
48 const char *INP_DIR_1080_20 = "/data/test/media/1920_1080_20M_30.h265";
49 const char *inpDirVivid = "/data/test/media/hlg_vivid_4k.h265";
50 const char *INP_DIR_VVC_1080 = "/data/test/media/1920_1080_10bit.vvc";
51 const char *inpDirVvcResolution = "/data/test/media/resolution.vvc";
52 const char *inpDirVvcResolution8Bit = "/data/test/media/resolution_8bit.vvc";
53 const char *inpDirVvcResolution10Bit = "/data/test/media/resolution_10bit.vvc";
54 const char *inpDirVvcResolutionHdr10Bit = "/data/test/media/resolution_hdr_10bit.vvc";
55 };
56 } // namespace Media
57 } // namespace OHOS
58
59 namespace {
60 static OH_AVCapability *cap = nullptr;
61 static OH_AVCapability *cap_hevc = nullptr;
62 static OH_AVCapability *cap_vvc = nullptr;
63 static string g_codecName = "";
64 static string g_codecNameHEVC = "";
65 static string g_codecNameVVC = "";
66 constexpr uint32_t CHANGE_AVC_FRAME = 1500;
67 constexpr uint32_t CHANGE_HEVC_FRAME = 3006;
68 } // namespace
69
SetUpTestCase()70 void HwdecFunc2NdkTest::SetUpTestCase()
71 {
72 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
73 g_codecName = OH_AVCapability_GetName(cap);
74 cout << "codecname: " << g_codecName << endl;
75 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
76 g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
77 cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
78 cap_vvc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
79 g_codecNameVVC = OH_AVCapability_GetName(cap_vvc);
80 cout << "g_codecNameVVC: " << g_codecNameVVC << endl;
81 }
TearDownTestCase()82 void HwdecFunc2NdkTest::TearDownTestCase() {}
SetUp()83 void HwdecFunc2NdkTest::SetUp() {}
TearDown()84 void HwdecFunc2NdkTest::TearDown() {}
85
86 namespace {
87 /**
88 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0010
89 * @tc.name : setcallback-config
90 * @tc.desc : function test
91 */
92 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0010, TestSize.Level2)
93 {
94 if (cap != nullptr) {
95 auto vDecSample = make_unique<VDecAPI11Sample>();
96 vDecSample->enbleSyncMode = 1;
97 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
98 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
99 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->ConfigureVideoDecoder());
100 }
101 }
102
103 /**
104 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0020
105 * @tc.name : setcallback-start-queryInputBuffer
106 * @tc.desc : function test
107 */
108 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0020, TestSize.Level2)
109 {
110 if (cap != nullptr) {
111 auto vDecSample = make_unique<VDecAPI11Sample>();
112 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
113 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
114 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
115 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
116 uint32_t index = 0;
117 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->QueryInputBuffer(index, 0));
118 }
119 }
120
121 /**
122 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0030
123 * @tc.name : setcallback-start-QueryOutputBuffer
124 * @tc.desc : function test
125 */
126 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0030, TestSize.Level2)
127 {
128 if (cap != nullptr) {
129 auto vDecSample = make_unique<VDecAPI11Sample>();
130 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
131 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
132 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
133 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
134 uint32_t index = 0;
135 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->QueryOutputBuffer(index, 0));
136 }
137 }
138
139 /**
140 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0040
141 * @tc.name : config sync -setcallback
142 * @tc.desc : function test
143 */
144 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0040, TestSize.Level2)
145 {
146 if (cap != nullptr) {
147 auto vDecSample = make_unique<VDecAPI11Sample>();
148 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
149 vDecSample->enbleSyncMode = 1;
150 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
151 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SetVideoDecoderCallback());
152 }
153 }
154
155 /**
156 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0050
157 * @tc.name : config sync -setcallback
158 * @tc.desc : function test
159 */
160 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0050, TestSize.Level2)
161 {
162 if (cap != nullptr) {
163 auto vDecSample = make_unique<VDecAPI11Sample>();
164 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
165 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
166 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
167 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
168 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
169 vDecSample->enbleSyncMode = 1;
170 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
171 }
172 }
173
174 /**
175 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0060
176 * @tc.name : flush-queryInputBuffer
177 * @tc.desc : function test
178 */
179 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0060, TestSize.Level2)
180 {
181 if (cap != nullptr) {
182 auto vDecSample = make_unique<VDecAPI11Sample>();
183 vDecSample->enbleSyncMode = 1;
184 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
185 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
186 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
187 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
188 uint32_t index = 0;
189 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->QueryInputBuffer(index, 0));
190 }
191 }
192
193 /**
194 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0070
195 * @tc.name : flush-queryOutputBuffer
196 * @tc.desc : function test
197 */
198 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0070, TestSize.Level2)
199 {
200 if (cap != nullptr) {
201 auto vDecSample = make_unique<VDecAPI11Sample>();
202 vDecSample->enbleSyncMode = 1;
203 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
204 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
205 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
206 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
207 uint32_t index = 0;
208 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->QueryOutputBuffer(index, 0));
209 }
210 }
211
212 /**
213 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0080
214 * @tc.name : GetInputBuffer repeated index
215 * @tc.desc : function test
216 */
217 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0080, TestSize.Level2)
218 {
219 if (cap != nullptr) {
220 auto vDecSample = make_unique<VDecAPI11Sample>();
221 vDecSample->INP_DIR = INP_DIR_1080_30;
222 vDecSample->enbleSyncMode = 1;
223 vDecSample->getInputBufferIndexRepeat = true;
224 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
225 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
226 ASSERT_EQ(AV_ERR_OK, vDecSample->OpenFile());
227 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
228 vDecSample->SyncInputFunc();
229 ASSERT_EQ(true, vDecSample->abnormalIndexValue);
230 }
231 }
232
233 /**
234 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0090
235 * @tc.name : GetInputBuffer nonexistent index
236 * @tc.desc : function test
237 */
238 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0090, TestSize.Level2)
239 {
240 if (cap != nullptr) {
241 auto vDecSample = make_unique<VDecAPI11Sample>();
242 vDecSample->enbleSyncMode = 1;
243 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
244 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
245 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
246 uint32_t index = 0;
247 ASSERT_EQ(AV_ERR_OK, vDecSample->QueryInputBuffer(index, -1));
248 ASSERT_EQ(nullptr, vDecSample->GetInputBuffer(index+100));
249 }
250 }
251
252 /**
253 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0100
254 * @tc.name : GetOutputBuffer repeated index
255 * @tc.desc : function test
256 */
257 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0100, TestSize.Level2)
258 {
259 if (cap_hevc != nullptr) {
260 auto vDecSample = make_unique<VDecAPI11Sample>();
261 vDecSample->INP_DIR = INP_DIR_1080_20;
262 vDecSample->DEFAULT_WIDTH = 1920;
263 vDecSample->DEFAULT_HEIGHT = 1080;
264 vDecSample->DEFAULT_FRAME_RATE = 30;
265 vDecSample->SF_OUTPUT = false;
266 vDecSample->outputYuvFlag = false;
267 vDecSample->enbleSyncMode = 1;
268 vDecSample->getOutputBufferIndexRepeated = true;
269 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
270 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
271 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
272 vDecSample->WaitForEOS();
273 ASSERT_EQ(true, vDecSample->abnormalIndexValue);
274 }
275 }
276
277 /**
278 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0110
279 * @tc.name : GetOutputBuffer nonexistent index
280 * @tc.desc : function test
281 */
282 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0110, TestSize.Level2)
283 {
284 if (cap_hevc != nullptr) {
285 auto vDecSample = make_unique<VDecAPI11Sample>();
286 vDecSample->INP_DIR = INP_DIR_1080_20;
287 vDecSample->DEFAULT_WIDTH = 1920;
288 vDecSample->DEFAULT_HEIGHT = 1080;
289 vDecSample->DEFAULT_FRAME_RATE = 30;
290 vDecSample->SF_OUTPUT = false;
291 vDecSample->outputYuvFlag = false;
292 vDecSample->enbleSyncMode = 1;
293 vDecSample->getOutputBufferIndexNoExisted = true;
294 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
295 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
296 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
297 vDecSample->WaitForEOS();
298 ASSERT_EQ(true, vDecSample->abnormalIndexValue);
299 }
300 }
301
302 /**
303 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0120
304 * @tc.name : sync decode queryInputBuffer timeout 0
305 * @tc.desc : function test
306 */
307 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0120, TestSize.Level0)
308 {
309 if (cap_hevc != nullptr) {
310 auto vDecSample = make_unique<VDecAPI11Sample>();
311 vDecSample->INP_DIR = INP_DIR_1080_20;
312 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0120.yuv";
313 vDecSample->DEFAULT_WIDTH = 1920;
314 vDecSample->DEFAULT_HEIGHT = 1080;
315 vDecSample->DEFAULT_FRAME_RATE = 30;
316 vDecSample->SF_OUTPUT = false;
317 vDecSample->outputYuvFlag = false;
318 vDecSample->enbleSyncMode = 1;
319 vDecSample->syncInputWaitTime = 0;
320 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
321 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
322 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
323 vDecSample->WaitForEOS();
324 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
325 }
326 }
327
328 /**
329 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0130
330 * @tc.name : sync decode queryInputBuffer timeout 100000
331 * @tc.desc : function test
332 */
333 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0130, TestSize.Level1)
334 {
335 if (cap_hevc != nullptr) {
336 auto vDecSample = make_unique<VDecAPI11Sample>();
337 vDecSample->INP_DIR = INP_DIR_1080_20;
338 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0130.yuv";
339 vDecSample->DEFAULT_WIDTH = 1920;
340 vDecSample->DEFAULT_HEIGHT = 1080;
341 vDecSample->DEFAULT_FRAME_RATE = 30;
342 vDecSample->SF_OUTPUT = false;
343 vDecSample->outputYuvFlag = false;
344 vDecSample->enbleSyncMode = 1;
345 vDecSample->syncInputWaitTime = 100000;
346 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
347 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
348 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
349 vDecSample->WaitForEOS();
350 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
351 }
352 }
353
354 /**
355 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0140
356 * @tc.name : sync decode syncOutputWaitTime timeout 0
357 * @tc.desc : function test
358 */
359 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0140, TestSize.Level0)
360 {
361 if (cap_hevc != nullptr) {
362 auto vDecSample = make_unique<VDecAPI11Sample>();
363 vDecSample->INP_DIR = INP_DIR_1080_20;
364 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0140.yuv";
365 vDecSample->DEFAULT_WIDTH = 1920;
366 vDecSample->DEFAULT_HEIGHT = 1080;
367 vDecSample->DEFAULT_FRAME_RATE = 30;
368 vDecSample->SF_OUTPUT = false;
369 vDecSample->outputYuvFlag = false;
370 vDecSample->enbleSyncMode = 1;
371 vDecSample->syncOutputWaitTime = 0;
372 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
373 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
374 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
375 vDecSample->WaitForEOS();
376 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
377 }
378 }
379
380 /**
381 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0150
382 * @tc.name : sync decode syncOutputWaitTime timeout 100000
383 * @tc.desc : function test
384 */
385 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0150, TestSize.Level1)
386 {
387 if (cap_hevc != nullptr) {
388 auto vDecSample = make_unique<VDecAPI11Sample>();
389 vDecSample->INP_DIR = INP_DIR_1080_20;
390 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0150.yuv";
391 vDecSample->DEFAULT_WIDTH = 1920;
392 vDecSample->DEFAULT_HEIGHT = 1080;
393 vDecSample->DEFAULT_FRAME_RATE = 30;
394 vDecSample->SF_OUTPUT = false;
395 vDecSample->outputYuvFlag = false;
396 vDecSample->enbleSyncMode = 1;
397 vDecSample->syncOutputWaitTime = 100000;
398 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
399 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
400 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
401 vDecSample->WaitForEOS();
402 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
403 }
404 }
405
406 /**
407 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0160
408 * @tc.name : get eos queryInputBuffer
409 * @tc.desc : function test
410 */
411 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0160, TestSize.Level2)
412 {
413 if (cap_hevc != nullptr) {
414 auto vDecSample = make_unique<VDecAPI11Sample>();
415 vDecSample->INP_DIR = INP_DIR_1080_20;
416 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0160.yuv";
417 vDecSample->DEFAULT_WIDTH = 1920;
418 vDecSample->DEFAULT_HEIGHT = 1080;
419 vDecSample->DEFAULT_FRAME_RATE = 30;
420 vDecSample->SF_OUTPUT = false;
421 vDecSample->outputYuvFlag = false;
422 vDecSample->enbleSyncMode = 1;
423 vDecSample->queryInputBufferEOS = true;
424 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
425 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
426 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
427 vDecSample->WaitForEOS();
428 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
429 }
430 }
431
432 /**
433 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0170
434 * @tc.name : get eos queryOutputBuffer
435 * @tc.desc : function test
436 */
437 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0170, TestSize.Level2)
438 {
439 if (cap_hevc != nullptr) {
440 auto vDecSample = make_unique<VDecAPI11Sample>();
441 vDecSample->INP_DIR = INP_DIR_1080_20;
442 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0170.yuv";
443 vDecSample->DEFAULT_WIDTH = 1920;
444 vDecSample->DEFAULT_HEIGHT = 1080;
445 vDecSample->DEFAULT_FRAME_RATE = 30;
446 vDecSample->SF_OUTPUT = false;
447 vDecSample->outputYuvFlag = false;
448 vDecSample->enbleSyncMode = 1;
449 vDecSample->queryOutputBufferEOS = true;
450 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
451 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
452 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
453 vDecSample->WaitForEOS();
454 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
455 }
456 }
457
458 /**
459 * @tc.number : VIDEO_DECODE_SYNC_HW264_FUNC_0010
460 * @tc.name : 264同步解码输出nv12
461 * @tc.desc : function test
462 */
463 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_FUNC_0010, TestSize.Level0)
464 {
465 if (cap != nullptr) {
466 auto vDecSample = make_shared<VDecAPI11Sample>();
467 vDecSample->INP_DIR = INP_DIR_1080_30;
468 vDecSample->DEFAULT_WIDTH = 1920;
469 vDecSample->DEFAULT_HEIGHT = 1080;
470 vDecSample->DEFAULT_FRAME_RATE = 30;
471 vDecSample->SF_OUTPUT = false;
472 vDecSample->outputYuvFlag = false;
473 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
474 vDecSample->enbleSyncMode = 1;
475 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
476 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
477 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
478 vDecSample->WaitForEOS();
479 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
480 }
481 }
482
483 /**
484 * @tc.number : VIDEO_DECODE_SYNC_HW264_FUNC_0020
485 * @tc.name : 264同步解码输出nv21
486 * @tc.desc : function test
487 */
488 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_FUNC_0020, TestSize.Level1)
489 {
490 if (cap != nullptr) {
491 auto vDecSample = make_shared<VDecAPI11Sample>();
492 vDecSample->INP_DIR = INP_DIR_1080_30;
493 vDecSample->DEFAULT_WIDTH = 1920;
494 vDecSample->DEFAULT_HEIGHT = 1080;
495 vDecSample->DEFAULT_FRAME_RATE = 30;
496 vDecSample->SF_OUTPUT = false;
497 vDecSample->outputYuvFlag = false;
498 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
499 vDecSample->enbleSyncMode = 1;
500 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
501 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
502 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
503 vDecSample->WaitForEOS();
504 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
505 }
506 }
507
508 /**
509 * @tc.number : VIDEO_DECODE_SYNC_HW264_FUNC_0030
510 * @tc.name : 264同步解码输出surface
511 * @tc.desc : function test
512 */
513 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_FUNC_0030, TestSize.Level0)
514 {
515 if (cap != nullptr) {
516 auto vDecSample = make_shared<VDecAPI11Sample>();
517 vDecSample->INP_DIR = INP_DIR_1080_30;
518 vDecSample->DEFAULT_WIDTH = 1920;
519 vDecSample->DEFAULT_HEIGHT = 1080;
520 vDecSample->DEFAULT_FRAME_RATE = 30;
521 vDecSample->SF_OUTPUT = true;
522 vDecSample->outputYuvFlag = false;
523 vDecSample->enbleSyncMode = 1;
524 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
525 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
526 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
527 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
528 vDecSample->WaitForEOS();
529 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
530 }
531 }
532
533 /**
534 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0010
535 * @tc.name : 265同步解码输出nv12
536 * @tc.desc : function test
537 */
538 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0010, TestSize.Level0)
539 {
540 if (cap_hevc != nullptr) {
541 auto vDecSample = make_shared<VDecAPI11Sample>();
542 vDecSample->INP_DIR = INP_DIR_1080_20;
543 vDecSample->DEFAULT_WIDTH = 1920;
544 vDecSample->DEFAULT_HEIGHT = 1080;
545 vDecSample->DEFAULT_FRAME_RATE = 30;
546 vDecSample->SF_OUTPUT = false;
547 vDecSample->outputYuvFlag = false;
548 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
549 vDecSample->enbleSyncMode = 1;
550 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
551 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
552 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
553 vDecSample->WaitForEOS();
554 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
555 }
556 }
557
558 /**
559 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0020
560 * @tc.name : 265同步解码输出nv21
561 * @tc.desc : function test
562 */
563 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0020, TestSize.Level2)
564 {
565 if (cap_hevc != nullptr) {
566 auto vDecSample = make_shared<VDecAPI11Sample>();
567 vDecSample->INP_DIR = INP_DIR_1080_20;
568 vDecSample->DEFAULT_WIDTH = 1920;
569 vDecSample->DEFAULT_HEIGHT = 1080;
570 vDecSample->DEFAULT_FRAME_RATE = 30;
571 vDecSample->SF_OUTPUT = false;
572 vDecSample->outputYuvFlag = false;
573 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
574 vDecSample->enbleSyncMode = 1;
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->StartVideoDecoder());
578 vDecSample->WaitForEOS();
579 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
580 }
581 }
582
583 /**
584 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0030
585 * @tc.name : 265同步解码输出surface
586 * @tc.desc : function test
587 */
588 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0030, TestSize.Level1)
589 {
590 if (cap_hevc != nullptr) {
591 auto vDecSample = make_shared<VDecAPI11Sample>();
592 vDecSample->INP_DIR = INP_DIR_1080_20;
593 vDecSample->DEFAULT_WIDTH = 1920;
594 vDecSample->DEFAULT_HEIGHT = 1080;
595 vDecSample->DEFAULT_FRAME_RATE = 30;
596 vDecSample->SF_OUTPUT = true;
597 vDecSample->outputYuvFlag = false;
598 vDecSample->enbleSyncMode = 1;
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->DecodeSetSurface());
602 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
603 vDecSample->WaitForEOS();
604 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
605 }
606 }
607
608 /**
609 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0040
610 * @tc.name : 265同步10bit解码
611 * @tc.desc : function test
612 */
613 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0040, TestSize.Level0)
614 {
615 if (cap_hevc != nullptr && !access("/system/lib64/media/", 0)) {
616 auto vDecSample = make_shared<VDecAPI11Sample>();
617 vDecSample->INP_DIR = inpDirVivid;
618 vDecSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN_10;
619 vDecSample->DEFAULT_WIDTH = 3840;
620 vDecSample->DEFAULT_HEIGHT = 2160;
621 vDecSample->DEFAULT_FRAME_RATE = 30;
622 vDecSample->SF_OUTPUT = false;
623 vDecSample->outputYuvFlag = true;
624 vDecSample->enbleSyncMode = 1;
625 vDecSample->useHDRSource = true;
626 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
627 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
628 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
629 vDecSample->WaitForEOS();
630 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
631 }
632 }
633
634 /**
635 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0010
636 * @tc.name : 266同步解码输出nv12
637 * @tc.desc : function test
638 */
639 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0010, TestSize.Level0)
640 {
641 if (g_codecNameVVC.find("hisi") != string::npos) {
642 auto vDecSample = make_shared<VDecAPI11Sample>();
643 vDecSample->INP_DIR = INP_DIR_VVC_1080;
644 vDecSample->DEFAULT_WIDTH = 1920;
645 vDecSample->DEFAULT_HEIGHT = 1080;
646 vDecSample->DEFAULT_FRAME_RATE = 30;
647 vDecSample->SF_OUTPUT = false;
648 vDecSample->outputYuvFlag = false;
649 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
650 vDecSample->enbleSyncMode = 1;
651 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
652 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
653 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
654 vDecSample->WaitForEOS();
655 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
656 }
657 }
658
659 /**
660 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0020
661 * @tc.name : 266同步解码输出nv21
662 * @tc.desc : function test
663 */
664 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0020, TestSize.Level2)
665 {
666 if (g_codecNameVVC.find("hisi") != string::npos) {
667 auto vDecSample = make_shared<VDecAPI11Sample>();
668 vDecSample->INP_DIR = INP_DIR_VVC_1080;
669 vDecSample->DEFAULT_WIDTH = 1920;
670 vDecSample->DEFAULT_HEIGHT = 1080;
671 vDecSample->DEFAULT_FRAME_RATE = 30;
672 vDecSample->SF_OUTPUT = false;
673 vDecSample->outputYuvFlag = false;
674 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
675 vDecSample->enbleSyncMode = 1;
676 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
677 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
678 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
679 vDecSample->WaitForEOS();
680 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
681 }
682 }
683
684 /**
685 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0030
686 * @tc.name : 266同步解码输出surface
687 * @tc.desc : function test
688 */
689 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0030, TestSize.Level1)
690 {
691 if (g_codecNameVVC.find("hisi") != string::npos) {
692 auto vDecSample = make_shared<VDecAPI11Sample>();
693 vDecSample->INP_DIR = INP_DIR_VVC_1080;
694 vDecSample->DEFAULT_WIDTH = 1920;
695 vDecSample->DEFAULT_HEIGHT = 1080;
696 vDecSample->DEFAULT_FRAME_RATE = 30;
697 vDecSample->SF_OUTPUT = true;
698 vDecSample->outputYuvFlag = false;
699 vDecSample->enbleSyncMode = 1;
700 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
701 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
702 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
703 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
704 vDecSample->WaitForEOS();
705 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
706 }
707 }
708
709 /**
710 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0040
711 * @tc.name : 266同步10bit解码
712 * @tc.desc : function test
713 */
714 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0040, TestSize.Level0)
715 {
716 if (g_codecNameVVC.find("hisi") != string::npos) {
717 auto vDecSample = make_shared<VDecAPI11Sample>();
718 vDecSample->INP_DIR = INP_DIR_VVC_1080;
719 vDecSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN_10;
720 vDecSample->DEFAULT_WIDTH = 3840;
721 vDecSample->DEFAULT_HEIGHT = 2160;
722 vDecSample->DEFAULT_FRAME_RATE = 30;
723 vDecSample->SF_OUTPUT = false;
724 vDecSample->outputYuvFlag = false;
725 vDecSample->enbleSyncMode = 1;
726 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
727 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
728 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
729 vDecSample->WaitForEOS();
730 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
731 }
732 }
733
734 /**
735 * @tc.number : VIDEO_DECODE_SYNC_HW264_CHANGE_FUNC_0010
736 * @tc.name : 分辨率切换h264硬解
737 * @tc.desc : function test
738 */
739 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_CHANGE_FUNC_0010, TestSize.Level2)
740 {
741 if (cap != nullptr) {
742 auto vDecSample = make_shared<VDecAPI11Sample>();
743 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
744 vDecSample->DEFAULT_WIDTH = 1104;
745 vDecSample->DEFAULT_HEIGHT = 622;
746 vDecSample->DEFAULT_FRAME_RATE = 30;
747 vDecSample->SF_OUTPUT = false;
748 vDecSample->NocaleHash = true;
749 vDecSample->enbleSyncMode = 1;
750 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
751 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
752 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
753 vDecSample->WaitForEOS();
754 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
755 ASSERT_EQ(CHANGE_AVC_FRAME, vDecSample->outFrameCount);
756 } else {
757 cout << "hardware encoder is rk,skip." << endl;
758 }
759 }
760
761 /**
762 * @tc.number : VIDEO_DECODE_SYNC_HW265_CHANGE_FUNC_0010
763 * @tc.name : 分辨率切换h265硬解
764 * @tc.desc : function test
765 */
766 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_CHANGE_FUNC_0010, TestSize.Level2)
767 {
768 if (cap_hevc != nullptr) {
769 auto vDecSample = make_shared<VDecAPI11Sample>();
770 vDecSample->INP_DIR = "/data/test/media/change_8bit_h265.h265";
771 vDecSample->DEFAULT_WIDTH = 1280;
772 vDecSample->DEFAULT_HEIGHT = 720;
773 vDecSample->DEFAULT_FRAME_RATE = 30;
774 vDecSample->SF_OUTPUT = false;
775 vDecSample->NocaleHash = true;
776 vDecSample->enbleSyncMode = 1;
777 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
778 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
779 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
780 vDecSample->WaitForEOS();
781 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
782 ASSERT_EQ(CHANGE_HEVC_FRAME, vDecSample->outFrameCount);
783 }
784 }
785
786 /**
787 * @tc.number : VIDEO_DECODE_SYNC_HW266_CHANGE_FUNC_0010
788 * @tc.name : 分辨率切换h266硬解
789 * @tc.desc : function test
790 */
791 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_CHANGE_FUNC_0010, TestSize.Level2)
792 {
793 if (g_codecNameVVC.find("hisi") != string::npos) {
794 auto vDecSample = make_shared<VDecAPI11Sample>();
795 vDecSample->INP_DIR = inpDirVvcResolution;
796 vDecSample->DEFAULT_WIDTH = 1104;
797 vDecSample->DEFAULT_HEIGHT = 622;
798 vDecSample->DEFAULT_FRAME_RATE = 30;
799 vDecSample->SF_OUTPUT = false;
800 vDecSample->enbleSyncMode = 1;
801 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
802 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
803 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
804 vDecSample->WaitForEOS();
805 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
806 }
807 }
808
809 /**
810 * @tc.number : VIDEO_DECODE_SYNC_HW264_SURCHANGE_FUNC_0010
811 * @tc.name : surface切换264硬解
812 * @tc.desc : function test
813 */
814 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_SURCHANGE_FUNC_0010, TestSize.Level2)
815 {
816 if (cap != nullptr) {
817 auto vDecSample = make_shared<VDecAPI11Sample>();
818 vDecSample->INP_DIR = INP_DIR_1080_30;
819 vDecSample->DEFAULT_WIDTH = 1920;
820 vDecSample->DEFAULT_HEIGHT = 1080;
821 vDecSample->DEFAULT_FRAME_RATE = 30;
822 vDecSample->SF_OUTPUT = true;
823 vDecSample->autoSwitchSurface = true;
824 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
825 vDecSample->sleepOnFPS = true;
826 vDecSample->enbleSyncMode = 1;
827 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
828 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
829 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
830 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
831 vDecSample->WaitForEOS();
832 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
833 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
834 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
835 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
836 }
837 }
838
839 /**
840 * @tc.number : VIDEO_DECODE_SYNC_HW265_SURCHANGE_FUNC_0010
841 * @tc.name : surface切换265硬解
842 * @tc.desc : function test
843 */
844 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_SURCHANGE_FUNC_0010, TestSize.Level2)
845 {
846 if (cap_hevc != nullptr) {
847 auto vDecSample = make_shared<VDecAPI11Sample>();
848 vDecSample->INP_DIR = INP_DIR_1080_20;
849 vDecSample->DEFAULT_WIDTH = 1920;
850 vDecSample->DEFAULT_HEIGHT = 1080;
851 vDecSample->DEFAULT_FRAME_RATE = 30;
852 vDecSample->SF_OUTPUT = true;
853 vDecSample->autoSwitchSurface = true;
854 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
855 vDecSample->sleepOnFPS = true;
856 vDecSample->enbleSyncMode = 1;
857 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
858 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
859 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
860 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
861 vDecSample->WaitForEOS();
862 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
863 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
864 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
865 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
866 }
867 }
868
869 /**
870 * @tc.number : VIDEO_DECODE_SYNC_HW266_SURCHANGE_FUNC_0010
871 * @tc.name : surface切换266硬解
872 * @tc.desc : function test
873 */
874 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_SURCHANGE_FUNC_0010, TestSize.Level2)
875 {
876 if (g_codecNameVVC.find("hisi") != string::npos) {
877 auto vDecSample = make_shared<VDecAPI11Sample>();
878 vDecSample->INP_DIR = INP_DIR_VVC_1080;
879 vDecSample->DEFAULT_WIDTH = 1920;
880 vDecSample->DEFAULT_HEIGHT = 1080;
881 vDecSample->DEFAULT_FRAME_RATE = 30;
882 vDecSample->SF_OUTPUT = true;
883 vDecSample->autoSwitchSurface = true;
884 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
885 vDecSample->sleepOnFPS = true;
886 vDecSample->enbleSyncMode = 1;
887 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
888 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
889 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
890 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
891 vDecSample->WaitForEOS();
892 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
893 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
894 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
895 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
896 }
897 }
898
899 /**
900 * @tc.number : VIDEO_DECODE_SYNC_HW264_ATTIME_FUNC_0010
901 * @tc.name : renderAtTime264硬解
902 * @tc.desc : function test
903 */
904 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_ATTIME_FUNC_0010, TestSize.Level2)
905 {
906 if (cap != nullptr) {
907 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
908 vDecSample->INP_DIR = INP_DIR_720_30;
909 vDecSample->SF_OUTPUT = true;
910 vDecSample->DEFAULT_WIDTH = 1280;
911 vDecSample->DEFAULT_HEIGHT = 720;
912 vDecSample->DEFAULT_FRAME_RATE = 30;
913 vDecSample->rsAtTime = true;
914 vDecSample->enbleSyncMode = 1;
915 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
916 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
917 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
918 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
919 vDecSample->WaitForEOS();
920 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
921 }
922 }
923
924 /**
925 * @tc.number : VIDEO_DECODE_SYNC_HW265_ATTIME_FUNC_0010
926 * @tc.name : renderAtTime265硬解
927 * @tc.desc : function test
928 */
929 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_ATTIME_FUNC_0010, TestSize.Level2)
930 {
931 if (cap_hevc != nullptr) {
932 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
933 vDecSample->INP_DIR = INP_DIR_1080_20;
934 vDecSample->SF_OUTPUT = true;
935 vDecSample->DEFAULT_WIDTH = 1920;
936 vDecSample->DEFAULT_HEIGHT = 1080;
937 vDecSample->DEFAULT_FRAME_RATE = 30;
938 vDecSample->rsAtTime = true;
939 vDecSample->enbleSyncMode = 1;
940 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
941 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
942 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
943 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
944 vDecSample->WaitForEOS();
945 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
946 }
947 }
948
949 /**
950 * @tc.number : VIDEO_DECODE_SYNC_HW266_ATTIME_FUNC_0010
951 * @tc.name : renderAtTime266硬解
952 * @tc.desc : function test
953 */
954 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_ATTIME_FUNC_0010, TestSize.Level2)
955 {
956 if (g_codecNameVVC.find("hisi") != string::npos) {
957 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
958 vDecSample->INP_DIR = INP_DIR_VVC_1080;
959 vDecSample->SF_OUTPUT = true;
960 vDecSample->DEFAULT_WIDTH = 1920;
961 vDecSample->DEFAULT_HEIGHT = 1080;
962 vDecSample->DEFAULT_FRAME_RATE = 30;
963 vDecSample->rsAtTime = true;
964 vDecSample->enbleSyncMode = 1;
965 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
966 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
967 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
968 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
969 vDecSample->WaitForEOS();
970 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
971 }
972 }
973
974 /**
975 * @tc.number : VIDEO_DECODE_SYNC_HW264_LOWLATENCY_FUNC_0010
976 * @tc.name : low latency264硬解
977 * @tc.desc : function test
978 */
979 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_LOWLATENCY_FUNC_0010, TestSize.Level2)
980 {
981 if (cap != nullptr) {
982 auto vDecSample = make_shared<VDecAPI11Sample>();
983 vDecSample->INP_DIR = INP_DIR_720_30;
984 vDecSample->DEFAULT_WIDTH = 1280;
985 vDecSample->DEFAULT_HEIGHT = 720;
986 vDecSample->DEFAULT_FRAME_RATE = 30;
987 vDecSample->enableLowLatency = true;
988 vDecSample->enbleSyncMode = 1;
989 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
990 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
991 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
992 vDecSample->WaitForEOS();
993 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
994 }
995 }
996
997 /**
998 * @tc.number : VIDEO_DECODE_SYNC_HW265_LOWLATENCY_FUNC_0010
999 * @tc.name : low latency265硬解
1000 * @tc.desc : function test
1001 */
1002 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_LOWLATENCY_FUNC_0010, TestSize.Level2)
1003 {
1004 if (cap_hevc != nullptr) {
1005 auto vDecSample = make_shared<VDecAPI11Sample>();
1006 vDecSample->INP_DIR = INP_DIR_1080_20;
1007 vDecSample->DEFAULT_WIDTH = 1920;
1008 vDecSample->DEFAULT_HEIGHT = 1080;
1009 vDecSample->DEFAULT_FRAME_RATE = 30;
1010 vDecSample->enableLowLatency = true;
1011 vDecSample->enbleSyncMode = 1;
1012 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
1013 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1014 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1015 vDecSample->WaitForEOS();
1016 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1017 }
1018 }
1019
1020 /**
1021 * @tc.number : VIDEO_DECODE_SYNC_HW266_LOWLATENCY_FUNC_0010
1022 * @tc.name : low latency266硬解
1023 * @tc.desc : function test
1024 */
1025 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_LOWLATENCY_FUNC_0010, TestSize.Level2)
1026 {
1027 if (g_codecNameVVC.find("hisi") != string::npos) {
1028 auto vDecSample = make_shared<VDecAPI11Sample>();
1029 vDecSample->INP_DIR = INP_DIR_VVC_1080;
1030 vDecSample->DEFAULT_WIDTH = 1920;
1031 vDecSample->DEFAULT_HEIGHT = 1080;
1032 vDecSample->DEFAULT_FRAME_RATE = 30;
1033 vDecSample->enableLowLatency = true;
1034 vDecSample->enbleSyncMode = 1;
1035 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1036 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1037 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1038 vDecSample->WaitForEOS();
1039 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1040 }
1041 }
1042
1043 /**
1044 * @tc.number : VIDEO_DECODE_SYNC_HW265_HDR2SDR_FUNC_0010
1045 * @tc.name : hdr2sdr 265硬解
1046 * @tc.desc : function test
1047 */
1048 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_HDR2SDR_FUNC_0010, TestSize.Level2)
1049 {
1050 if (cap_hevc != nullptr) {
1051 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1052 vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k_720p_1080p.h265";
1053 vDecSample->DEFAULT_WIDTH = 3840;
1054 vDecSample->DEFAULT_HEIGHT = 2160;
1055 vDecSample->SF_OUTPUT = true;
1056 vDecSample->TRANSFER_FLAG = true;
1057 vDecSample->enbleSyncMode = 1;
1058 if (!access("/system/lib64/media/", 0)) {
1059 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
1060 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1061 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1062 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1063 vDecSample->WaitForEOS();
1064 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1065 }
1066 else {
1067 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
1068 ASSERT_EQ(AV_ERR_UNSUPPORT, vDecSample->ConfigureVideoDecoder());
1069 vDecSample->WaitForEOS();
1070 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1071 }
1072 }
1073 }
1074
1075 /**
1076 * @tc.number : VIDEO_DECODE_FLUSH_FUNC_0010
1077 * @tc.name : 265硬解, check flush前后的buffer地址
1078 * @tc.desc : function test
1079 */
1080 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_FLUSH_FUNC_0010, TestSize.Level2)
1081 {
1082 if (cap_hevc != nullptr) {
1083 auto vDecSample = make_shared<VDecAPI11Sample>();
1084 vDecSample->INP_DIR = INP_DIR_1080_20;
1085 vDecSample->DEFAULT_WIDTH = 1920;
1086 vDecSample->DEFAULT_HEIGHT = 1080;
1087 vDecSample->DEFAULT_FRAME_RATE = 30;
1088 vDecSample->isCheckFlush = true;
1089 vDecSample->FLUSH_COUNTS = 1;
1090 vDecSample->NocaleHash = true;
1091 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
1092 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1093 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1094 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1095 vDecSample->WaitForEOS();
1096 ASSERT_NE(vDecSample->indexBufferAfter[1], vDecSample->indexBufferBefore[1]);
1097 ASSERT_NE(vDecSample->indexBufferAfter[2], vDecSample->indexBufferBefore[2]);
1098 }
1099 }
1100
1101 /**
1102 * @tc.number : VIDEO_DECODE_H264_BLANK_FRAME_0010
1103 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h264, buffer
1104 * @tc.desc : function test
1105 */
1106 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H264_BLANK_FRAME_0010, TestSize.Level0)
1107 {
1108 if (cap != nullptr) {
1109 auto vDecSample = make_shared<VDecAPI11Sample>();
1110 vDecSample->INP_DIR = INP_DIR_720_30;
1111 vDecSample->DEFAULT_WIDTH = 1280;
1112 vDecSample->DEFAULT_HEIGHT = 720;
1113 vDecSample->DEFAULT_FRAME_RATE = 30;
1114 vDecSample->enbleBlankFrame = 1;
1115 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
1116 vDecSample->WaitForEOS();
1117 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1118 }
1119 }
1120
1121 /**
1122 * @tc.number : VIDEO_DECODE_H264_BLANK_FRAME_0030
1123 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h264, surface
1124 * @tc.desc : function test
1125 */
1126 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H264_BLANK_FRAME_0030, TestSize.Level0)
1127 {
1128 if (cap != nullptr) {
1129 auto vDecSample = make_shared<VDecAPI11Sample>();
1130 vDecSample->INP_DIR = INP_DIR_720_30;
1131 vDecSample->DEFAULT_WIDTH = 1280;
1132 vDecSample->DEFAULT_HEIGHT = 720;
1133 vDecSample->DEFAULT_FRAME_RATE = 30;
1134 vDecSample->SF_OUTPUT = true;
1135 vDecSample->enbleBlankFrame = 1;
1136 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1137 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1138 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1139 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1140 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1141 vDecSample->WaitForEOS();
1142 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1143 }
1144 }
1145
1146 /**
1147 * @tc.number : VIDEO_DECODE_H265_BLANK_FRAME_0020
1148 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h265
1149 * @tc.desc : function test
1150 */
1151 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H265_BLANK_FRAME_0020, TestSize.Level2)
1152 {
1153 if (cap_hevc != nullptr) {
1154 auto vDecSample = make_shared<VDecAPI11Sample>();
1155 vDecSample->INP_DIR = INP_DIR_1080_20;
1156 vDecSample->DEFAULT_WIDTH = 1920;
1157 vDecSample->DEFAULT_HEIGHT = 1080;
1158 vDecSample->DEFAULT_FRAME_RATE = 30;
1159 vDecSample->enbleBlankFrame = 1;
1160 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
1161 vDecSample->WaitForEOS();
1162 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1163 }
1164 }
1165
1166 /**
1167 * @tc.number : VIDEO_DECODE_H265_BLANK_FRAME_0030
1168 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h265, surface
1169 * @tc.desc : function test
1170 */
1171 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H265_BLANK_FRAME_0030, TestSize.Level2)
1172 {
1173 if (cap_hevc != nullptr) {
1174 auto vDecSample = make_shared<VDecAPI11Sample>();
1175 vDecSample->INP_DIR = INP_DIR_1080_20;
1176 vDecSample->DEFAULT_WIDTH = 1920;
1177 vDecSample->DEFAULT_HEIGHT = 1080;
1178 vDecSample->DEFAULT_FRAME_RATE = 30;
1179 vDecSample->SF_OUTPUT = true;
1180 vDecSample->enbleBlankFrame = 1;
1181 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
1182 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1183 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1184 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1185 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1186 vDecSample->WaitForEOS();
1187 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1188 }
1189 }
1190
1191 /**
1192 * @tc.number : VIDEO_DECODE_H266_BLANK_FRAME_0020
1193 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h266, surface
1194 * @tc.desc : function test
1195 */
1196 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H266_BLANK_FRAME_0020, TestSize.Level2)
1197 {
1198 if (g_codecNameVVC.find("hisi") != string::npos) {
1199 auto vDecSample = make_shared<VDecAPI11Sample>();
1200 vDecSample->INP_DIR = INP_DIR_VVC_1080;
1201 vDecSample->DEFAULT_WIDTH = 1920;
1202 vDecSample->DEFAULT_HEIGHT = 1080;
1203 vDecSample->DEFAULT_FRAME_RATE = 30;
1204 vDecSample->SF_OUTPUT = true;
1205 vDecSample->enbleBlankFrame = 1;
1206 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1207 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1208 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1209 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1210 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1211 vDecSample->WaitForEOS();
1212 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1213 }
1214 }
1215
1216 /**
1217 * @tc.number : VIDEO_DECODE_H266_BLANK_FRAME_0030
1218 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h266
1219 * @tc.desc : function test
1220 */
1221 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H266_BLANK_FRAME_0030, TestSize.Level2)
1222 {
1223 if (g_codecNameVVC.find("hisi") != string::npos) {
1224 auto vDecSample = make_shared<VDecAPI11Sample>();
1225 vDecSample->INP_DIR = INP_DIR_VVC_1080;
1226 vDecSample->DEFAULT_WIDTH = 1920;
1227 vDecSample->DEFAULT_HEIGHT = 1080;
1228 vDecSample->DEFAULT_FRAME_RATE = 30;
1229 vDecSample->enbleBlankFrame = 1;
1230 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameVVC));
1231 vDecSample->WaitForEOS();
1232 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1233 }
1234 }
1235 } // namespace