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_api11_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 HwdecFunc2NdkTest : 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 const char *INP_DIR_1080_20 = "/data/test/media/1920_1080_20M_30.h265";
48 const char *inpDirVivid = "/data/test/media/hlg_vivid_4k.h265";
49 const char *INP_DIR_VVC_1080 = "/data/test/media/1920_1080_10bit.vvc";
50 };
51 } // namespace Media
52 } // namespace OHOS
53
54 namespace {
55 static OH_AVCapability *cap = nullptr;
56 static OH_AVCapability *cap_hevc = nullptr;
57 static OH_AVCapability *cap_vvc = nullptr;
58 static string g_codecName = "";
59 static string g_codecNameHEVC = "";
60 static string g_codecNameVVC = "";
61 } // namespace
62
SetUpTestCase()63 void HwdecFunc2NdkTest::SetUpTestCase()
64 {
65 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
66 g_codecName = OH_AVCapability_GetName(cap);
67 cout << "codecname: " << g_codecName << endl;
68 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
69 g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
70 cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
71 cap_vvc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
72 g_codecNameVVC = OH_AVCapability_GetName(cap_vvc);
73 cout << "g_codecNameVVC: " << g_codecNameVVC << endl;
74 }
TearDownTestCase()75 void HwdecFunc2NdkTest::TearDownTestCase() {}
SetUp()76 void HwdecFunc2NdkTest::SetUp() {}
TearDown()77 void HwdecFunc2NdkTest::TearDown() {}
78
79 namespace {
80 /**
81 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0010
82 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0010
83 * @tc.desc : function test
84 */
85 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0010, TestSize.Level2)
86 {
87 if (cap != nullptr) {
88 auto vDecSample = make_unique<VDecAPI11Sample>();
89 vDecSample->enbleSyncMode = 1;
90 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
91 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
92 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->ConfigureVideoDecoder());
93 }
94 }
95
96 /**
97 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0020
98 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0020
99 * @tc.desc : function test
100 */
101 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0020, TestSize.Level2)
102 {
103 if (cap != nullptr) {
104 auto vDecSample = make_unique<VDecAPI11Sample>();
105 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
106 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
107 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
108 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
109 uint32_t index = 0;
110 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->QueryInputBuffer(index, 0));
111 }
112 }
113
114 /**
115 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0030
116 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0030
117 * @tc.desc : function test
118 */
119 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0030, TestSize.Level2)
120 {
121 if (cap != nullptr) {
122 auto vDecSample = make_unique<VDecAPI11Sample>();
123 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
124 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
125 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
126 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
127 uint32_t index = 0;
128 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->QueryOutputBuffer(index, 0));
129 }
130 }
131
132 /**
133 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0040
134 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0040
135 * @tc.desc : function test
136 */
137 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0040, TestSize.Level2)
138 {
139 if (cap != nullptr) {
140 auto vDecSample = make_unique<VDecAPI11Sample>();
141 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
142 vDecSample->enbleSyncMode = 1;
143 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
144 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SetVideoDecoderCallback());
145 }
146 }
147
148 /**
149 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0050
150 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0050
151 * @tc.desc : function test
152 */
153 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0050, TestSize.Level2)
154 {
155 if (cap != nullptr) {
156 auto vDecSample = make_unique<VDecAPI11Sample>();
157 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
158 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
159 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
160 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
161 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
162 vDecSample->enbleSyncMode = 1;
163 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
164 }
165 }
166
167 /**
168 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0060
169 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0060
170 * @tc.desc : function test
171 */
172 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0060, TestSize.Level2)
173 {
174 if (cap != nullptr) {
175 auto vDecSample = make_unique<VDecAPI11Sample>();
176 vDecSample->enbleSyncMode = 1;
177 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
178 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
179 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
180 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
181 uint32_t index = 0;
182 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->QueryInputBuffer(index, 0));
183 }
184 }
185
186 /**
187 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0070
188 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0070
189 * @tc.desc : function test
190 */
191 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0070, TestSize.Level2)
192 {
193 if (cap != nullptr) {
194 auto vDecSample = make_unique<VDecAPI11Sample>();
195 vDecSample->enbleSyncMode = 1;
196 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
197 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
198 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
199 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
200 uint32_t index = 0;
201 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->QueryOutputBuffer(index, 0));
202 }
203 }
204
205 /**
206 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0080
207 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0080
208 * @tc.desc : function test
209 */
210 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0080, TestSize.Level2)
211 {
212 if (cap != nullptr) {
213 auto vDecSample = make_unique<VDecAPI11Sample>();
214 vDecSample->INP_DIR = INP_DIR_1080_30;
215 vDecSample->enbleSyncMode = 1;
216 vDecSample->getInputBufferIndexRepeat = true;
217 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
218 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
219 ASSERT_EQ(AV_ERR_OK, vDecSample->OpenFile());
220 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
221 vDecSample->SyncInputFunc();
222 ASSERT_EQ(true, vDecSample->abnormalIndexValue);
223 }
224 }
225
226 /**
227 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0090
228 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0090
229 * @tc.desc : function test
230 */
231 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0090, TestSize.Level2)
232 {
233 if (cap != nullptr) {
234 auto vDecSample = make_unique<VDecAPI11Sample>();
235 vDecSample->enbleSyncMode = 1;
236 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
237 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
238 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
239 uint32_t index = 0;
240 ASSERT_EQ(AV_ERR_OK, vDecSample->QueryInputBuffer(index, -1));
241 ASSERT_EQ(nullptr, vDecSample->GetInputBuffer(index+100));
242 }
243 }
244
245 /**
246 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0100
247 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0100
248 * @tc.desc : function test
249 */
250 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0100, TestSize.Level2)
251 {
252 if (cap_hevc != nullptr) {
253 auto vDecSample = make_unique<VDecAPI11Sample>();
254 vDecSample->INP_DIR = INP_DIR_1080_20;
255 vDecSample->DEFAULT_WIDTH = 1920;
256 vDecSample->DEFAULT_HEIGHT = 1080;
257 vDecSample->DEFAULT_FRAME_RATE = 30;
258 vDecSample->SF_OUTPUT = false;
259 vDecSample->outputYuvFlag = false;
260 vDecSample->enbleSyncMode = 1;
261 vDecSample->getOutputBufferIndexRepeated = true;
262 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
263 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
264 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
265 vDecSample->WaitForEOS();
266 ASSERT_EQ(true, vDecSample->abnormalIndexValue);
267 }
268 }
269
270 /**
271 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0110
272 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0110
273 * @tc.desc : function test
274 */
275 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0110, TestSize.Level2)
276 {
277 if (cap_hevc != nullptr) {
278 auto vDecSample = make_unique<VDecAPI11Sample>();
279 vDecSample->INP_DIR = INP_DIR_1080_20;
280 vDecSample->DEFAULT_WIDTH = 1920;
281 vDecSample->DEFAULT_HEIGHT = 1080;
282 vDecSample->DEFAULT_FRAME_RATE = 30;
283 vDecSample->SF_OUTPUT = false;
284 vDecSample->outputYuvFlag = false;
285 vDecSample->enbleSyncMode = 1;
286 vDecSample->getOutputBufferIndexNoExisted = true;
287 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
288 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
289 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
290 vDecSample->WaitForEOS();
291 ASSERT_EQ(true, vDecSample->abnormalIndexValue);
292 }
293 }
294
295 /**
296 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0120
297 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0120
298 * @tc.desc : function test
299 */
300 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0120, TestSize.Level0)
301 {
302 if (cap_hevc != nullptr) {
303 auto vDecSample = make_unique<VDecAPI11Sample>();
304 vDecSample->INP_DIR = INP_DIR_1080_20;
305 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0120.yuv";
306 vDecSample->DEFAULT_WIDTH = 1920;
307 vDecSample->DEFAULT_HEIGHT = 1080;
308 vDecSample->DEFAULT_FRAME_RATE = 30;
309 vDecSample->SF_OUTPUT = false;
310 vDecSample->outputYuvFlag = false;
311 vDecSample->enbleSyncMode = 1;
312 vDecSample->syncInputWaitTime = 0;
313 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
314 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
315 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
316 vDecSample->WaitForEOS();
317 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
318 }
319 }
320
321 /**
322 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0130
323 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0130
324 * @tc.desc : function test
325 */
326 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0130, TestSize.Level1)
327 {
328 if (cap_hevc != nullptr) {
329 auto vDecSample = make_unique<VDecAPI11Sample>();
330 vDecSample->INP_DIR = INP_DIR_1080_20;
331 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0130.yuv";
332 vDecSample->DEFAULT_WIDTH = 1920;
333 vDecSample->DEFAULT_HEIGHT = 1080;
334 vDecSample->DEFAULT_FRAME_RATE = 30;
335 vDecSample->SF_OUTPUT = false;
336 vDecSample->outputYuvFlag = false;
337 vDecSample->enbleSyncMode = 1;
338 vDecSample->syncInputWaitTime = 100000;
339 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
340 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
341 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
342 vDecSample->WaitForEOS();
343 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
344 }
345 }
346
347 /**
348 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0140
349 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0140
350 * @tc.desc : function test
351 */
352 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0140, TestSize.Level0)
353 {
354 if (cap_hevc != nullptr) {
355 auto vDecSample = make_unique<VDecAPI11Sample>();
356 vDecSample->INP_DIR = INP_DIR_1080_20;
357 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0140.yuv";
358 vDecSample->DEFAULT_WIDTH = 1920;
359 vDecSample->DEFAULT_HEIGHT = 1080;
360 vDecSample->DEFAULT_FRAME_RATE = 30;
361 vDecSample->SF_OUTPUT = false;
362 vDecSample->outputYuvFlag = false;
363 vDecSample->enbleSyncMode = 1;
364 vDecSample->syncOutputWaitTime = 0;
365 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
366 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
367 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
368 vDecSample->WaitForEOS();
369 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
370 }
371 }
372
373 /**
374 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0150
375 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0150
376 * @tc.desc : function test
377 */
378 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0150, TestSize.Level1)
379 {
380 if (cap_hevc != nullptr) {
381 auto vDecSample = make_unique<VDecAPI11Sample>();
382 vDecSample->INP_DIR = INP_DIR_1080_20;
383 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0150.yuv";
384 vDecSample->DEFAULT_WIDTH = 1920;
385 vDecSample->DEFAULT_HEIGHT = 1080;
386 vDecSample->DEFAULT_FRAME_RATE = 30;
387 vDecSample->SF_OUTPUT = false;
388 vDecSample->outputYuvFlag = false;
389 vDecSample->enbleSyncMode = 1;
390 vDecSample->syncOutputWaitTime = 100000;
391 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
392 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
393 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
394 vDecSample->WaitForEOS();
395 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
396 }
397 }
398
399 /**
400 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0160
401 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0160
402 * @tc.desc : function test
403 */
404 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0160, TestSize.Level2)
405 {
406 if (cap_hevc != nullptr) {
407 auto vDecSample = make_unique<VDecAPI11Sample>();
408 vDecSample->INP_DIR = INP_DIR_1080_20;
409 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0160.yuv";
410 vDecSample->DEFAULT_WIDTH = 1920;
411 vDecSample->DEFAULT_HEIGHT = 1080;
412 vDecSample->DEFAULT_FRAME_RATE = 30;
413 vDecSample->SF_OUTPUT = false;
414 vDecSample->outputYuvFlag = false;
415 vDecSample->enbleSyncMode = 1;
416 vDecSample->queryInputBufferEOS = true;
417 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
418 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
419 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
420 vDecSample->WaitForEOS();
421 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
422 }
423 }
424
425 /**
426 * @tc.number : VIDEO_DECODE_SYNC_FUNC_0170
427 * @tc.name : VIDEO_DECODE_SYNC_FUNC_0170
428 * @tc.desc : function test
429 */
430 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_FUNC_0170, TestSize.Level2)
431 {
432 if (cap_hevc != nullptr) {
433 auto vDecSample = make_unique<VDecAPI11Sample>();
434 vDecSample->INP_DIR = INP_DIR_1080_20;
435 vDecSample->OUT_DIR = "/data/test/media/VIDEO_DECODE_SYNC_0170.yuv";
436 vDecSample->DEFAULT_WIDTH = 1920;
437 vDecSample->DEFAULT_HEIGHT = 1080;
438 vDecSample->DEFAULT_FRAME_RATE = 30;
439 vDecSample->SF_OUTPUT = false;
440 vDecSample->outputYuvFlag = false;
441 vDecSample->enbleSyncMode = 1;
442 vDecSample->queryOutputBufferEOS = true;
443 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
444 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
445 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
446 vDecSample->WaitForEOS();
447 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
448 }
449 }
450
451 /**
452 * @tc.number : VIDEO_DECODE_SYNC_HW264_FUNC_0010
453 * @tc.name : VIDEO_DECODE_SYNC_HW264_FUNC_0010
454 * @tc.desc : function test
455 */
456 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_FUNC_0010, TestSize.Level0)
457 {
458 if (cap != nullptr) {
459 auto vDecSample = make_shared<VDecAPI11Sample>();
460 vDecSample->INP_DIR = INP_DIR_1080_30;
461 vDecSample->DEFAULT_WIDTH = 1920;
462 vDecSample->DEFAULT_HEIGHT = 1080;
463 vDecSample->DEFAULT_FRAME_RATE = 30;
464 vDecSample->SF_OUTPUT = false;
465 vDecSample->outputYuvFlag = false;
466 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
467 vDecSample->enbleSyncMode = 1;
468 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
469 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
470 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
471 vDecSample->WaitForEOS();
472 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
473 }
474 }
475
476 /**
477 * @tc.number : VIDEO_DECODE_SYNC_HW264_FUNC_0020
478 * @tc.name : VIDEO_DECODE_SYNC_HW264_FUNC_0020
479 * @tc.desc : function test
480 */
481 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_FUNC_0020, TestSize.Level1)
482 {
483 if (cap != nullptr) {
484 auto vDecSample = make_shared<VDecAPI11Sample>();
485 vDecSample->INP_DIR = INP_DIR_1080_30;
486 vDecSample->DEFAULT_WIDTH = 1920;
487 vDecSample->DEFAULT_HEIGHT = 1080;
488 vDecSample->DEFAULT_FRAME_RATE = 30;
489 vDecSample->SF_OUTPUT = false;
490 vDecSample->outputYuvFlag = false;
491 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
492 vDecSample->enbleSyncMode = 1;
493 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
494 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
495 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
496 vDecSample->WaitForEOS();
497 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
498 }
499 }
500
501 /**
502 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0010
503 * @tc.name : VIDEO_DECODE_SYNC_HW265_FUNC_0010
504 * @tc.desc : function test
505 */
506 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0010, TestSize.Level0)
507 {
508 if (cap_hevc != nullptr) {
509 auto vDecSample = make_shared<VDecAPI11Sample>();
510 vDecSample->INP_DIR = INP_DIR_1080_20;
511 vDecSample->DEFAULT_WIDTH = 1920;
512 vDecSample->DEFAULT_HEIGHT = 1080;
513 vDecSample->DEFAULT_FRAME_RATE = 30;
514 vDecSample->SF_OUTPUT = false;
515 vDecSample->outputYuvFlag = false;
516 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
517 vDecSample->enbleSyncMode = 1;
518 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
519 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
520 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
521 vDecSample->WaitForEOS();
522 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
523 }
524 }
525
526 /**
527 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0020
528 * @tc.name : VIDEO_DECODE_SYNC_HW265_FUNC_0020
529 * @tc.desc : function test
530 */
531 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0020, TestSize.Level2)
532 {
533 if (cap_hevc != nullptr) {
534 auto vDecSample = make_shared<VDecAPI11Sample>();
535 vDecSample->INP_DIR = INP_DIR_1080_20;
536 vDecSample->DEFAULT_WIDTH = 1920;
537 vDecSample->DEFAULT_HEIGHT = 1080;
538 vDecSample->DEFAULT_FRAME_RATE = 30;
539 vDecSample->SF_OUTPUT = false;
540 vDecSample->outputYuvFlag = false;
541 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
542 vDecSample->enbleSyncMode = 1;
543 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
544 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
545 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
546 vDecSample->WaitForEOS();
547 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
548 }
549 }
550
551 /**
552 * @tc.number : VIDEO_DECODE_SYNC_HW265_FUNC_0040
553 * @tc.name : VIDEO_DECODE_SYNC_HW265_FUNC_0040
554 * @tc.desc : function test
555 */
556 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_FUNC_0040, TestSize.Level0)
557 {
558 if (cap_hevc != nullptr && !access("/system/lib64/media/", 0)) {
559 auto vDecSample = make_shared<VDecAPI11Sample>();
560 vDecSample->INP_DIR = inpDirVivid;
561 vDecSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN_10;
562 vDecSample->DEFAULT_WIDTH = 3840;
563 vDecSample->DEFAULT_HEIGHT = 2160;
564 vDecSample->DEFAULT_FRAME_RATE = 30;
565 vDecSample->SF_OUTPUT = false;
566 vDecSample->outputYuvFlag = false;
567 vDecSample->enbleSyncMode = 1;
568 vDecSample->useHDRSource = true;
569 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
570 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
571 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
572 vDecSample->WaitForEOS();
573 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
574 }
575 }
576
577 /**
578 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0010
579 * @tc.name : VIDEO_DECODE_SYNC_HW266_FUNC_0010
580 * @tc.desc : function test
581 */
582 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0010, TestSize.Level0)
583 {
584 if (g_codecNameVVC.find("hisi") != string::npos) {
585 auto vDecSample = make_shared<VDecAPI11Sample>();
586 vDecSample->INP_DIR = INP_DIR_VVC_1080;
587 vDecSample->DEFAULT_WIDTH = 1920;
588 vDecSample->DEFAULT_HEIGHT = 1080;
589 vDecSample->DEFAULT_FRAME_RATE = 30;
590 vDecSample->SF_OUTPUT = false;
591 vDecSample->outputYuvFlag = false;
592 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
593 vDecSample->enbleSyncMode = 1;
594 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
595 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
596 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
597 vDecSample->WaitForEOS();
598 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
599 }
600 }
601
602 /**
603 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0020
604 * @tc.name : VIDEO_DECODE_SYNC_HW266_FUNC_0020
605 * @tc.desc : function test
606 */
607 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0020, TestSize.Level2)
608 {
609 if (g_codecNameVVC.find("hisi") != string::npos) {
610 auto vDecSample = make_shared<VDecAPI11Sample>();
611 vDecSample->INP_DIR = INP_DIR_VVC_1080;
612 vDecSample->DEFAULT_WIDTH = 1920;
613 vDecSample->DEFAULT_HEIGHT = 1080;
614 vDecSample->DEFAULT_FRAME_RATE = 30;
615 vDecSample->SF_OUTPUT = false;
616 vDecSample->outputYuvFlag = false;
617 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
618 vDecSample->enbleSyncMode = 1;
619 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
620 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
621 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
622 vDecSample->WaitForEOS();
623 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
624 }
625 }
626
627 /**
628 * @tc.number : VIDEO_DECODE_SYNC_HW266_FUNC_0040
629 * @tc.name : VIDEO_DECODE_SYNC_HW266_FUNC_0040
630 * @tc.desc : function test
631 */
632 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_FUNC_0040, TestSize.Level0)
633 {
634 if (g_codecNameVVC.find("hisi") != string::npos) {
635 auto vDecSample = make_shared<VDecAPI11Sample>();
636 vDecSample->INP_DIR = INP_DIR_VVC_1080;
637 vDecSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN_10;
638 vDecSample->DEFAULT_WIDTH = 3840;
639 vDecSample->DEFAULT_HEIGHT = 2160;
640 vDecSample->DEFAULT_FRAME_RATE = 30;
641 vDecSample->SF_OUTPUT = false;
642 vDecSample->outputYuvFlag = false;
643 vDecSample->enbleSyncMode = 1;
644 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
645 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
646 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
647 vDecSample->WaitForEOS();
648 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
649 }
650 }
651
652 /**
653 * @tc.number : VIDEO_DECODE_SYNC_HW264_LOWLATENCY_FUNC_0010
654 * @tc.name : VIDEO_DECODE_SYNC_HW264_LOWLATENCY_FUNC_0010
655 * @tc.desc : function test
656 */
657 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW264_LOWLATENCY_FUNC_0010, TestSize.Level2)
658 {
659 if (cap != nullptr) {
660 auto vDecSample = make_shared<VDecAPI11Sample>();
661 vDecSample->INP_DIR = INP_DIR_720_30;
662 vDecSample->DEFAULT_WIDTH = 1280;
663 vDecSample->DEFAULT_HEIGHT = 720;
664 vDecSample->DEFAULT_FRAME_RATE = 30;
665 vDecSample->enableLowLatency = true;
666 vDecSample->enbleSyncMode = 1;
667 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
668 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
669 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
670 vDecSample->WaitForEOS();
671 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
672 }
673 }
674
675 /**
676 * @tc.number : VIDEO_DECODE_SYNC_HW265_LOWLATENCY_FUNC_0010
677 * @tc.name : VIDEO_DECODE_SYNC_HW265_LOWLATENCY_FUNC_0010
678 * @tc.desc : function test
679 */
680 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW265_LOWLATENCY_FUNC_0010, TestSize.Level2)
681 {
682 if (cap_hevc != nullptr) {
683 auto vDecSample = make_shared<VDecAPI11Sample>();
684 vDecSample->INP_DIR = INP_DIR_1080_20;
685 vDecSample->DEFAULT_WIDTH = 1920;
686 vDecSample->DEFAULT_HEIGHT = 1080;
687 vDecSample->DEFAULT_FRAME_RATE = 30;
688 vDecSample->enableLowLatency = true;
689 vDecSample->enbleSyncMode = 1;
690 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
691 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
692 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
693 vDecSample->WaitForEOS();
694 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
695 }
696 }
697
698 /**
699 * @tc.number : VIDEO_DECODE_SYNC_HW266_LOWLATENCY_FUNC_0010
700 * @tc.name : VIDEO_DECODE_SYNC_HW266_LOWLATENCY_FUNC_0010
701 * @tc.desc : function test
702 */
703 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_SYNC_HW266_LOWLATENCY_FUNC_0010, TestSize.Level2)
704 {
705 if (g_codecNameVVC.find("hisi") != string::npos) {
706 auto vDecSample = make_shared<VDecAPI11Sample>();
707 vDecSample->INP_DIR = INP_DIR_VVC_1080;
708 vDecSample->DEFAULT_WIDTH = 1920;
709 vDecSample->DEFAULT_HEIGHT = 1080;
710 vDecSample->DEFAULT_FRAME_RATE = 30;
711 vDecSample->enableLowLatency = true;
712 vDecSample->enbleSyncMode = 1;
713 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
714 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
715 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
716 vDecSample->WaitForEOS();
717 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
718 }
719 }
720
721 /**
722 * @tc.number : VIDEO_DECODE_H264_BLANK_FRAME_0010
723 * @tc.name : VIDEO_DECODE_H264_BLANK_FRAME_0010
724 * @tc.desc : function test
725 */
726 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H264_BLANK_FRAME_0010, TestSize.Level0)
727 {
728 if (cap != nullptr) {
729 auto vDecSample = make_shared<VDecAPI11Sample>();
730 vDecSample->INP_DIR = INP_DIR_720_30;
731 vDecSample->DEFAULT_WIDTH = 1280;
732 vDecSample->DEFAULT_HEIGHT = 720;
733 vDecSample->DEFAULT_FRAME_RATE = 30;
734 vDecSample->enbleBlankFrame = 1;
735 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
736 vDecSample->WaitForEOS();
737 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
738 }
739 }
740
741 /**
742 * @tc.number : VIDEO_DECODE_H265_BLANK_FRAME_0020
743 * @tc.name : VIDEO_DECODE_H265_BLANK_FRAME_0020
744 * @tc.desc : function test
745 */
746 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H265_BLANK_FRAME_0020, TestSize.Level0)
747 {
748 if (cap_hevc != nullptr) {
749 auto vDecSample = make_shared<VDecAPI11Sample>();
750 vDecSample->INP_DIR = INP_DIR_1080_20;
751 vDecSample->DEFAULT_WIDTH = 1920;
752 vDecSample->DEFAULT_HEIGHT = 1080;
753 vDecSample->DEFAULT_FRAME_RATE = 30;
754 vDecSample->enbleBlankFrame = 1;
755 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
756 vDecSample->WaitForEOS();
757 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
758 }
759 }
760
761 /**
762 * @tc.number : VIDEO_DECODE_H266_BLANK_FRAME_0030
763 * @tc.name : VIDEO_DECODE_H266_BLANK_FRAME_0030
764 * @tc.desc : function test
765 */
766 HWTEST_F(HwdecFunc2NdkTest, VIDEO_DECODE_H266_BLANK_FRAME_0030, TestSize.Level0)
767 {
768 if (g_codecNameVVC.find("hisi") != string::npos) {
769 auto vDecSample = make_shared<VDecAPI11Sample>();
770 vDecSample->INP_DIR = INP_DIR_VVC_1080;
771 vDecSample->DEFAULT_WIDTH = 1920;
772 vDecSample->DEFAULT_HEIGHT = 1080;
773 vDecSample->DEFAULT_FRAME_RATE = 30;
774 vDecSample->enbleBlankFrame = 1;
775 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameVVC));
776 vDecSample->WaitForEOS();
777 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
778 }
779 }
780 } // namespace