1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <iostream>
17 #include <cstdio>
18 #include <atomic>
19 #include <fstream>
20 #include <thread>
21 #include <mutex>
22 #include <queue>
23 #include <string>
24
25 #include "gtest/gtest.h"
26 #include "videodec_ndk_sample.h"
27 #include "videodec_api11_sample.h"
28 #include "native_avcodec_videodecoder.h"
29 #include "native_avformat.h"
30 #include "native_averrors.h"
31 #include "native_avcodec_base.h"
32 #include "native_avcapability.h"
33
34 using namespace std;
35 using namespace OHOS;
36 using namespace OHOS::Media;
37 using namespace testing::ext;
38 namespace OHOS {
39 namespace Media {
40 class HwdecApiNdkTest : public testing::Test {
41 public:
42 // SetUpTestCase: Called before all test cases
43 static void SetUpTestCase(void);
44 // TearDownTestCase: Called after all test case
45 static void TearDownTestCase(void);
46 // SetUp: Called before each test cases
47 void SetUp(void);
48 // TearDown: Called after each test cases
49 void TearDown(void);
50 };
51
52 namespace {
53 OH_AVCodec *vdec_ = NULL;
54 OH_AVCapability *cap = nullptr;
55 OH_AVCapability *cap_hevc = nullptr;
56 VDecSignal *signal_;
57 const string INVALID_CODEC_NAME = "avdec_h264";
58 string g_codecName;
59 string g_codecNameHEVC;
60 OH_AVFormat *format;
61 constexpr uint32_t DEFAULT_WIDTH = 1920;
62 constexpr uint32_t DEFAULT_HEIGHT = 1080;
63 constexpr double DEFAULT_FRAME_RATE = 30.0;
64 } // namespace
65
SetUpTestCase()66 void HwdecApiNdkTest::SetUpTestCase()
67 {
68 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
69 g_codecName = OH_AVCapability_GetName(cap);
70 cout << "g_codecName: " << g_codecName << endl;
71 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
72 g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
73 cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
74 }
TearDownTestCase()75 void HwdecApiNdkTest::TearDownTestCase() {}
SetUp()76 void HwdecApiNdkTest::SetUp()
77 {
78 signal_ = new VDecSignal();
79 }
TearDown()80 void HwdecApiNdkTest::TearDown()
81 {
82 if (format != nullptr) {
83 OH_AVFormat_Destroy(format);
84 format = nullptr;
85 }
86 if (signal_) {
87 delete signal_;
88 signal_ = nullptr;
89 }
90 if (vdec_ != NULL) {
91 OH_VideoDecoder_Destroy(vdec_);
92 vdec_ = nullptr;
93 }
94 }
95 } // namespace Media
96 } // namespace OHOS
97
98 namespace {
VDecNeedInputData(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,void * userData)99 void VDecNeedInputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)
100 {
101 cout << "VDecNeedInputData index:" << index << endl;
102 VDecSignal *signal = static_cast<VDecSignal *>(userData);
103 unique_lock<mutex> lock(signal->inMutex_);
104 signal->inIdxQueue_.push(index);
105 signal->inCond_.notify_all();
106 }
107
108 /**
109 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0100
110 * @tc.name : OH_VideoDecoder_FindDecoder para error
111 * @tc.desc : function test
112 */
113 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0100, TestSize.Level2)
114 {
115 vdec_ = OH_VideoDecoder_CreateByMime(NULL);
116 ASSERT_EQ(NULL, vdec_);
117 }
118
119 /**
120 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0200
121 * @tc.name : OH_VideoDecoder_CreateByName para error
122 * @tc.desc : function test
123 */
124 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0200, TestSize.Level2)
125 {
126 vdec_ = OH_VideoDecoder_CreateByName(NULL);
127 ASSERT_EQ(NULL, vdec_);
128 }
129
130 /**
131 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3300
132 * @tc.name : OH_VideoDecoder_SetCallback para error
133 * @tc.desc : function test
134 */
135 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3300, TestSize.Level2)
136 {
137 OH_AVCodecAsyncCallback cb_;
138 cb_.onError = VdecError;
139 cb_.onStreamChanged = VdecFormatChanged;
140 cb_.onNeedInputData = VdecInputDataReady;
141 cb_.onNeedOutputData = VdecOutputDataReady;
142 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
143 }
144
145 /**
146 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1800
147 * @tc.name : OH_VideoDecoder_SetCallback para error
148 * @tc.desc : function test
149 */
150 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1800, TestSize.Level2)
151 {
152 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
153 ASSERT_NE(NULL, vdec_);
154
155 OH_AVCodecAsyncCallback cb2_;
156 cb2_.onError = NULL;
157 cb2_.onStreamChanged = NULL;
158 cb2_.onNeedInputData = NULL;
159 cb2_.onNeedOutputData = NULL;
160 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb2_, static_cast<void *>(signal_)));
161 }
162
163 /**
164 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0300
165 * @tc.name : OH_VideoDecoder_SetCallback para error
166 * @tc.desc : function test
167 */
168 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0300, TestSize.Level2)
169 {
170 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
171 OH_AVCodecAsyncCallback cb_;
172 cb_.onError = VdecError;
173 cb_.onStreamChanged = VdecFormatChanged;
174 cb_.onNeedInputData = VdecInputDataReady;
175 cb_.onNeedOutputData = VdecOutputDataReady;
176 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
177 }
178
179 /**
180 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0400
181 * @tc.name : OH_VideoDecoder_Destroy para error
182 * @tc.desc : function test
183 */
184 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0400, TestSize.Level2)
185 {
186 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(NULL));
187 }
188
189 /**
190 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0500
191 * @tc.name : OH_VideoDecoder_Configure para error
192 * @tc.desc : function test
193 */
194 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0500, TestSize.Level2)
195 {
196 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
197 ASSERT_NE(NULL, vdec_);
198 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, NULL));
199 }
200
201 /**
202 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1400
203 * @tc.name : OH_VideoDecoder_Configure para error
204 * @tc.desc : function test
205 */
206 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1400, TestSize.Level2)
207 {
208 format = OH_AVFormat_Create();
209 ASSERT_NE(NULL, format);
210 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
211 }
212
213 /**
214 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1400
215 * @tc.name : OH_VideoDecoder_Configure para error
216 * @tc.desc : function test
217 */
218 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_5000, TestSize.Level2)
219 {
220 format = OH_AVFormat_Create();
221 ASSERT_NE(NULL, format);
222 string widthStr = "width";
223 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
224 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
225 }
226
227 /**
228 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1400
229 * @tc.name : OH_VideoDecoder_Configure para error
230 * @tc.desc : function test
231 */
232 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_5100, TestSize.Level2)
233 {
234 format = OH_AVFormat_Create();
235 ASSERT_NE(NULL, format);
236
237 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
238 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
239 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
240 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
241 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
242 }
243
244 /**
245 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0600
246 * @tc.name : OH_VideoDecoder_Start para error
247 * @tc.desc : function test
248 */
249 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0600, TestSize.Level2)
250 {
251 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Start(NULL));
252 }
253
254 /**
255 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0700
256 * @tc.name : OH_VideoDecoder_Stop para error
257 * @tc.desc : function test
258 */
259 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0700, TestSize.Level2)
260 {
261 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Stop(NULL));
262 }
263
264 /**
265 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0800
266 * @tc.name : OH_VideoDecoder_Flush para error
267 * @tc.desc : function test
268 */
269 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0800, TestSize.Level2)
270 {
271 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Flush(NULL));
272 }
273
274 /**
275 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0900
276 * @tc.name : OH_VideoDecoder_Reset para error
277 * @tc.desc : function test
278 */
279 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0900, TestSize.Level2)
280 {
281 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Reset(NULL));
282 }
283
284 /**
285 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1000
286 * @tc.name : OH_VideoDecoder_GetOutputDescription para error
287 * @tc.desc : function test
288 */
289 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1000, TestSize.Level2)
290 {
291 ASSERT_EQ(NULL, OH_VideoDecoder_GetOutputDescription(NULL));
292 }
293
294 /**
295 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1100
296 * @tc.name : OH_VideoDecoder_SetParameter para error
297 * @tc.desc : function test
298 */
299 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1100, TestSize.Level2)
300 {
301 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
302 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(vdec_, NULL));
303 }
304
305 /**
306 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_4100
307 * @tc.name : OH_VideoDecoder_Prepare para error
308 * @tc.desc : function test
309 */
310 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_4100, TestSize.Level2)
311 {
312 OH_AVErrCode ret = AV_ERR_OK;
313 ret = OH_VideoDecoder_Prepare(nullptr);
314 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
315 }
316
317 /**
318 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1500
319 * @tc.name : OH_VideoDecoder_SetParameter para error
320 * @tc.desc : function test
321 */
322 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1500, TestSize.Level2)
323 {
324 format = OH_AVFormat_Create();
325 ASSERT_NE(NULL, format);
326
327 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
328 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
329 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
330 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
331 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(NULL, format));
332 }
333
334 /**
335 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1200
336 * @tc.name : OH_VideoDecoder_SetSurface para error
337 * @tc.desc : function test
338 */
339 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1200, TestSize.Level2)
340 {
341 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
342 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetSurface(vdec_, NULL));
343 }
344
345 /**
346 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1300
347 * @tc.name : OH_VideoDecoder_CreateByName para correct
348 * @tc.desc : function test
349 */
350 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1300, TestSize.Level2)
351 {
352 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
353 }
354
355 /**
356 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1600
357 * @tc.name : OH_VideoDecoder_CreateByName para error
358 * @tc.desc : function test
359 */
360 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1600, TestSize.Level2)
361 {
362 vdec_ = OH_VideoDecoder_CreateByName(INVALID_CODEC_NAME.c_str());
363 ASSERT_EQ(NULL, vdec_);
364 }
365
366 /**
367 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1700
368 * @tc.name : OH_VideoDecoder_CreateByName para error
369 * @tc.desc : function test
370 */
371 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1700, TestSize.Level2)
372 {
373 vdec_ = OH_VideoDecoder_CreateByMime(INVALID_CODEC_NAME.c_str());
374 ASSERT_EQ(NULL, vdec_);
375 }
376
377 /**
378 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1700
379 * @tc.name : OH_VideoDecoder_IsValid para error
380 * @tc.desc : function test
381 */
382 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2200, TestSize.Level2)
383 {
384 bool isValid = false;
385 OH_AVErrCode ret = AV_ERR_OK;
386 ret = OH_VideoDecoder_IsValid(nullptr, &isValid);
387 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
388 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
389 ASSERT_NE(NULL, vdec_);
390 ret = OH_VideoDecoder_IsValid(vdec_, nullptr);
391 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
392 }
393
394 /**
395 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2500
396 * @tc.name : OH_VideoDecoder_RenderOutputData para error
397 * @tc.desc : function test
398 */
399 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2500, TestSize.Level2)
400 {
401 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_RenderOutputData(NULL, 0));
402 }
403
404 /**
405 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2600
406 * @tc.name : OH_VideoDecoder_RenderOutputData para error
407 * @tc.desc : function test
408 */
409 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2600, TestSize.Level2)
410 {
411 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
412 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_RenderOutputData(vdec_, 0));
413 }
414
415 /**
416 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2700
417 * @tc.name : OH_VideoDecoder_FreeOutputData para error
418 * @tc.desc : function test
419 */
420 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2700, TestSize.Level2)
421 {
422 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_FreeOutputData(NULL, 0));
423 }
424
425 /**
426 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2800
427 * @tc.name : OH_VideoDecoder_FreeOutputData para error
428 * @tc.desc : function test
429 */
430 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2800, TestSize.Level2)
431 {
432 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
433 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, 0));
434 }
435
436 /**
437 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2900
438 * @tc.name : OH_VideoDecoder_FreeOutputData para error
439 * @tc.desc : function test
440 */
441 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2900, TestSize.Level2)
442 {
443 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
444 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, -1));
445 }
446
447 /**
448 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3000
449 * @tc.name : OH_VideoDecoder_PushInputData para error
450 * @tc.desc : function test
451 */
452 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3000, TestSize.Level2)
453 {
454 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
455
456 OH_AVCodecBufferAttr attr;
457 attr.pts = -1;
458 attr.size = -1;
459 attr.offset = -1;
460 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
461
462 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
463 }
464
465 /**
466 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3100
467 * @tc.name : OH_VideoDecoder_PushInputData para error
468 * @tc.desc : function test
469 */
470 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3100, TestSize.Level2)
471 {
472 OH_AVCodecBufferAttr attr;
473 attr.pts = 0;
474 attr.size = 0;
475 attr.offset = 0;
476 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
477
478 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, -1, attr));
479 }
480
481 /**
482 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3200
483 * @tc.name : OH_VideoDecoder_PushInputData para error
484 * @tc.desc : function test
485 */
486 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3200, TestSize.Level2)
487 {
488 OH_AVCodecBufferAttr attr;
489 attr.pts = 0;
490 attr.size = 0;
491 attr.offset = 0;
492 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
493
494 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, 0, attr));
495 }
496
497 /**
498 * @tc.number : VIDEO_HWDEC_API_0100
499 * @tc.name : create create
500 * @tc.desc : function test
501 */
502 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0100, TestSize.Level2)
503 {
504 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
505 ASSERT_NE(vdec_, NULL);
506 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByName(g_codecName.c_str());
507 ASSERT_NE(vdec_2, NULL);
508 OH_VideoDecoder_Destroy(vdec_2);
509 vdec_2 = nullptr;
510 }
511
512 /**
513 * @tc.number : VIDEO_HWDEC_API_0200
514 * @tc.name : create configure configure
515 * @tc.desc : function test
516 */
517 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0200, TestSize.Level2)
518 {
519 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
520 ASSERT_NE(NULL, vdec_);
521
522 format = OH_AVFormat_Create();
523 ASSERT_NE(NULL, format);
524
525 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
526 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
527 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
528 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
529
530 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
531 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Configure(vdec_, format));
532 }
533
534 /**
535 * @tc.number : VIDEO_HWDEC_API_0300
536 * @tc.name : create configure start start
537 * @tc.desc : function test
538 */
539 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0300, TestSize.Level2)
540 {
541 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
542 ASSERT_NE(NULL, vdec_);
543
544 format = OH_AVFormat_Create();
545 ASSERT_NE(NULL, format);
546
547 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
548 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
549 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
550 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
551
552 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
553 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
554 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Start(vdec_));
555 }
556
557 /**
558 * @tc.number : VIDEO_HWDEC_API_0400
559 * @tc.name : create configure start stop stop
560 * @tc.desc : function test
561 */
562 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0400, TestSize.Level2)
563 {
564 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
565 ASSERT_NE(NULL, vdec_);
566
567 format = OH_AVFormat_Create();
568 ASSERT_NE(NULL, format);
569
570 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
571 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
572 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
573 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
574
575 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
576 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
577 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
578 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
579 }
580
581 /**
582 * @tc.number : VIDEO_HWDEC_API_0500
583 * @tc.name : create configure start stop reset reset
584 * @tc.desc : function test
585 */
586 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0500, TestSize.Level2)
587 {
588 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
589 ASSERT_NE(NULL, vdec_);
590
591 format = OH_AVFormat_Create();
592 ASSERT_NE(NULL, format);
593
594 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
595 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
596 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
597 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
598
599 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
600 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
601 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
602 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
603 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
604 }
605
606 /**
607 * @tc.number : VIDEO_HWDEC_API_0600
608 * @tc.name : create configure start EOS EOS
609 * @tc.desc : function test
610 */
611 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0600, TestSize.Level2)
612 {
613 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
614 ASSERT_NE(NULL, vdec_);
615 format = OH_AVFormat_Create();
616 ASSERT_NE(NULL, format);
617 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
618 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
619 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
620 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
621 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
622 OH_AVCodecAsyncCallback cb_;
623 cb_.onError = VdecError;
624 cb_.onStreamChanged = VdecFormatChanged;
625 cb_.onNeedInputData = VDecNeedInputData;
626 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, static_cast<void *>(signal_)));
627 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
628 for (int i = 0; i < 2; i++) {
629 unique_lock<mutex> lock(signal_->inMutex_);
__anon1ff1e1c70302() 630 signal_->inCond_.wait(lock, []() { return signal_->inIdxQueue_.size() > 0; });
631 uint32_t index = signal_->inIdxQueue_.front();
632 OH_AVCodecBufferAttr attr;
633 attr.pts = 0;
634 attr.size = 0;
635 attr.offset = 0;
636 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
637 cout << "OH_VideoDecoder_PushInputData index:" << index << endl;
638 if (i == 0) {
639 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_PushInputData(vdec_, index, attr));
640 } else {
641 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
642 }
643 }
644 OH_VideoDecoder_Destroy(vdec_);
645 vdec_ = nullptr;
646 signal_->inIdxQueue_.pop();
647 }
648
649 /**
650 * @tc.number : VIDEO_HWDEC_API_0700
651 * @tc.name : create configure start flush flush
652 * @tc.desc : function test
653 */
654 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0700, TestSize.Level2)
655 {
656 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
657 ASSERT_NE(NULL, vdec_);
658
659 format = OH_AVFormat_Create();
660 ASSERT_NE(NULL, format);
661
662 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
663 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
664 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
665 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
666
667 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
668 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
669 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
670 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
671 }
672
673 /**
674 * @tc.number : VIDEO_HWDEC_API_0800
675 * @tc.name : create configure start stop release release
676 * @tc.desc : function test
677 */
678 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0800, TestSize.Level2)
679 {
680 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
681 ASSERT_NE(NULL, vdec_);
682
683 format = OH_AVFormat_Create();
684 ASSERT_NE(NULL, format);
685
686 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
687 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
688 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
689 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
690
691 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
692 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
693 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
694 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
695 vdec_ = nullptr;
696 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
697 }
698
699 /**
700 * @tc.number : VIDEO_HWDEC_API_0900
701 * @tc.name : create create
702 * @tc.desc : function test
703 */
704 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0900, TestSize.Level2)
705 {
706 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
707 ASSERT_NE(vdec_, NULL);
708 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
709 ASSERT_NE(vdec_2, NULL);
710 OH_VideoDecoder_Destroy(vdec_2);
711 vdec_2 = nullptr;
712 }
713
714 /**
715 * @tc.number : VIDEO_HWDEC_API_1000
716 * @tc.name : repeat OH_VideoDecoder_SetCallback
717 * @tc.desc : function test
718 */
719 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1000, TestSize.Level2)
720 {
721 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
722 OH_AVCodecAsyncCallback cb_;
723 cb_.onError = VdecError;
724 cb_.onStreamChanged = VdecFormatChanged;
725 cb_.onNeedInputData = VdecInputDataReady;
726 cb_.onNeedOutputData = VdecOutputDataReady;
727 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
728 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
729 }
730
731 /**
732 * @tc.number : VIDEO_HWDEC_API_1100
733 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
734 * @tc.desc : function test
735 */
736 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1100, TestSize.Level2)
737 {
738 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
739 format = OH_VideoDecoder_GetOutputDescription(vdec_);
740 ASSERT_NE(NULL, format);
741 format = OH_VideoDecoder_GetOutputDescription(vdec_);
742 ASSERT_NE(NULL, format);
743 }
744
745 /**
746 * @tc.number : VIDEO_HWDEC_API_1200
747 * @tc.name : repeat OH_VideoDecoder_SetParameter
748 * @tc.desc : function test
749 */
750 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1200, TestSize.Level2)
751 {
752 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
753 ASSERT_NE(NULL, vdec_);
754
755 format = OH_AVFormat_Create();
756 ASSERT_NE(NULL, format);
757
758 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
759 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
760 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
761 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
762
763 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
764 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
765 }
766
767 /**
768 * @tc.number : VIDEO_HWDEC_CAP_API_0100
769 * @tc.name : OH_AVCodec_GetCapability
770 * @tc.desc : function test
771 */
772 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0100, TestSize.Level2)
773 {
774 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false);
775 ASSERT_NE(cap, nullptr);
776 }
777
778 /**
779 * @tc.number : VIDEO_HWDEC_CAP_API_0200
780 * @tc.name : OH_AVCodec_GetCapability
781 * @tc.desc : function test
782 */
783 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0200, TestSize.Level2)
784 {
785 cap = OH_AVCodec_GetCapability(nullptr, false);
786 ASSERT_EQ(cap, nullptr);
787 }
788
789 /**
790 * @tc.number : VIDEO_HWDEC_CAP_API_0300
791 * @tc.name : OH_AVCodec_GetCapability
792 * @tc.desc : function test
793 */
794 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0300, TestSize.Level2)
795 {
796 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
797 ASSERT_NE(cap, nullptr);
798 }
799
800 /**
801 * @tc.number : VIDEO_HWDEC_CAP_API_0400
802 * @tc.name : OH_AVCodec_GetCapability
803 * @tc.desc : function test
804 */
805 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0400, TestSize.Level2)
806 {
807 cap = OH_AVCodec_GetCapabilityByCategory(nullptr, false, HARDWARE);
808 ASSERT_EQ(cap, nullptr);
809 }
810
811 /**
812 * @tc.number : VIDEO_HWDEC_CAP_API_0500
813 * @tc.name : OH_AVCodec_GetCapability
814 * @tc.desc : function test
815 */
816 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0500, TestSize.Level2)
817 {
818 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
819 ASSERT_NE(cap, nullptr);
820 ASSERT_TRUE(OH_AVCapability_IsHardware(cap));
821 }
822
823 /**
824 * @tc.number : VIDEO_HWDEC_CAP_API_0600
825 * @tc.name : OH_AVCodec_GetCapability
826 * @tc.desc : function test
827 */
828 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0600, TestSize.Level2)
829 {
830 ASSERT_FALSE(OH_AVCapability_IsHardware(nullptr));
831 }
832
833 /**
834 * @tc.number : VIDEO_HWDEC_CAP_API_0700
835 * @tc.name : OH_AVCodec_GetCapability
836 * @tc.desc : function test
837 */
838 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0700, TestSize.Level2)
839 {
840 ASSERT_EQ(0, OH_AVCapability_GetMaxSupportedInstances(nullptr));
841 }
842
843 /**
844 * @tc.number : VIDEO_HWDEC_CAP_API_0800
845 * @tc.name : OH_AVCodec_GetCapability
846 * @tc.desc : function test, 不同平台解码器数量不一致, 改为不校验具体数量
847 */
848 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0800, TestSize.Level2)
849 {
850 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
851 ASSERT_NE(cap, nullptr);
852 string codec_name = OH_AVCapability_GetName(cap);
853 if (codec_name == "OMX.hisi.video.decoder.avc") {
854 ASSERT_LT(1, OH_AVCapability_GetMaxSupportedInstances(cap));
855 } else {
856 ASSERT_EQ(6, OH_AVCapability_GetMaxSupportedInstances(cap));
857 }
858 }
859
860 /**
861 * @tc.number : VIDEO_HWDEC_CAP_API_0900
862 * @tc.name : OH_AVCodec_GetCapability
863 * @tc.desc : function test
864 */
865 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0900, TestSize.Level2)
866 {
867 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
868 ASSERT_NE(cap, nullptr);
869 ASSERT_EQ(g_codecName, OH_AVCapability_GetName(cap));
870 }
871
872 /**
873 * @tc.number : VIDEO_HWDEC_CAP_API_1000
874 * @tc.name : OH_AVCodec_GetCapability
875 * @tc.desc : function test
876 */
877 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1000, TestSize.Level2)
878 {
879 const char *name = OH_AVCapability_GetName(nullptr);
880 ASSERT_NE(name, nullptr);
881 ASSERT_EQ(strlen(name), 0);
882 }
883
884 /**
885 * @tc.number : VIDEO_HWDEC_CAP_API_3100
886 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
887 * @tc.desc : api test
888 */
889 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3100, TestSize.Level2)
890 {
891 OH_AVErrCode ret = AV_ERR_OK;
892 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
893 ASSERT_NE(nullptr, capability);
894 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
895 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
896 }
897
898 /**
899 * @tc.number : VIDEO_HWDEC_CAP_API_3200
900 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
901 * @tc.desc : api test
902 */
903 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3200, TestSize.Level2)
904 {
905 OH_AVErrCode ret = AV_ERR_OK;
906 int32_t alignment = 0;
907 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
908 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
909 }
910
911 /**
912 * @tc.number : VIDEO_HWDEC_CAP_API_3300
913 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
914 * @tc.desc : api test
915 */
916 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3300, TestSize.Level2)
917 {
918 OH_AVErrCode ret = AV_ERR_OK;
919 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
920 ASSERT_NE(nullptr, capability);
921 int32_t alignment = 0;
922 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
923 cout << "WidthAlignment " << alignment << endl;
924 ASSERT_EQ(AV_ERR_OK, ret);
925 ASSERT_GE(alignment, 0);
926 }
927
928 /**
929 * @tc.number : VIDEO_HWDEC_CAP_API_3400
930 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
931 * @tc.desc : api test
932 */
933 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3400, TestSize.Level2)
934 {
935 OH_AVErrCode ret = AV_ERR_OK;
936 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
937 ASSERT_NE(nullptr, capability);
938 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
939 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
940 }
941
942 /**
943 * @tc.number : VIDEO_HWDEC_CAP_API_3500
944 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
945 * @tc.desc : api test
946 */
947 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3500, TestSize.Level2)
948 {
949 OH_AVErrCode ret = AV_ERR_OK;
950 int32_t alignment = 0;
951 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
952 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
953 }
954
955 /**
956 * @tc.number : VIDEO_HWDEC_CAP_API_3600
957 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
958 * @tc.desc : api test
959 */
960 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3600, TestSize.Level2)
961 {
962 OH_AVErrCode ret = AV_ERR_OK;
963 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
964 ASSERT_NE(nullptr, capability);
965 int32_t alignment = 0;
966 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
967 cout << "HeightAlignment " << alignment << endl;
968 ASSERT_EQ(AV_ERR_OK, ret);
969 ASSERT_GE(alignment, 0);
970 }
971
972 /**
973 * @tc.number : VIDEO_HWDEC_CAP_API_3700
974 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
975 * @tc.desc : api test
976 */
977 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3700, TestSize.Level2)
978 {
979 OH_AVErrCode ret = AV_ERR_OK;
980 OH_AVRange range;
981 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
982 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
983 ASSERT_NE(nullptr, capability);
984 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range);
985 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
986 }
987
988 /**
989 * @tc.number : VIDEO_HWDEC_CAP_API_3800
990 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
991 * @tc.desc : api test
992 */
993 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3800, TestSize.Level2)
994 {
995 OH_AVErrCode ret = AV_ERR_OK;
996 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
997 ASSERT_NE(nullptr, capability);
998 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, nullptr);
999 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1000 }
1001
1002 /**
1003 * @tc.number : VIDEO_HWDEC_CAP_API_3900
1004 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1005 * @tc.desc : api test
1006 */
1007 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3900, TestSize.Level2)
1008 {
1009 OH_AVErrCode ret = AV_ERR_OK;
1010 OH_AVRange range;
1011 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1012 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1013 ASSERT_NE(nullptr, capability);
1014 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
1015 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1016 }
1017
1018 /**
1019 * @tc.number : VIDEO_HWDEC_CAP_API_4000
1020 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1021 * @tc.desc : api test
1022 */
1023 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4000, TestSize.Level2)
1024 {
1025 OH_AVErrCode ret = AV_ERR_OK;
1026 OH_AVRange range;
1027 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1028 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1029 ASSERT_NE(nullptr, capability);
1030 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
1031 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1032 ASSERT_EQ(AV_ERR_OK, ret);
1033 ASSERT_GE(range.minVal, 0);
1034 ASSERT_GT(range.maxVal, 0);
1035 }
1036
1037 /**
1038 * @tc.number : VIDEO_HWDEC_CAP_API_4100
1039 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1040 * @tc.desc : api test
1041 */
1042 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4100, TestSize.Level2)
1043 {
1044 OH_AVErrCode ret = AV_ERR_OK;
1045 OH_AVRange range;
1046 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1047 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1048 ASSERT_NE(nullptr, capability);
1049 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1050 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1051 }
1052
1053 /**
1054 * @tc.number : VIDEO_HWDEC_CAP_API_4200
1055 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1056 * @tc.desc : api test
1057 */
1058 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4200, TestSize.Level2)
1059 {
1060 OH_AVErrCode ret = AV_ERR_OK;
1061 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1062 ASSERT_NE(nullptr, capability);
1063 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1064 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1065 }
1066
1067 /**
1068 * @tc.number : VIDEO_HWDEC_CAP_API_4300
1069 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1070 * @tc.desc : api test
1071 */
1072 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4300, TestSize.Level2)
1073 {
1074 OH_AVErrCode ret = AV_ERR_OK;
1075 OH_AVRange range;
1076 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1077 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1078 ASSERT_NE(nullptr, capability);
1079 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1080 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1081 }
1082
1083 /**
1084 * @tc.number : VIDEO_HWDEC_CAP_API_4400
1085 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1086 * @tc.desc : api test
1087 */
1088 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4400, TestSize.Level2)
1089 {
1090 OH_AVErrCode ret = AV_ERR_OK;
1091 OH_AVRange range;
1092 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1093 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1094 ASSERT_NE(nullptr, capability);
1095 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1096 ASSERT_EQ(AV_ERR_OK, ret);
1097 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1098 ASSERT_GE(range.minVal, 0);
1099 ASSERT_GT(range.maxVal, 0);
1100 }
1101
1102 /**
1103 * @tc.number : VIDEO_HWDEC_CAP_API_4500
1104 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1105 * @tc.desc : api test
1106 */
1107 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4500, TestSize.Level2)
1108 {
1109 OH_AVErrCode ret = AV_ERR_OK;
1110 OH_AVRange range;
1111 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1112 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1113 }
1114
1115 /**
1116 * @tc.number : VIDEO_HWDEC_CAP_API_4600
1117 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1118 * @tc.desc : api test
1119 */
1120 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4600, TestSize.Level2)
1121 {
1122 OH_AVErrCode ret = AV_ERR_OK;
1123 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1124 ASSERT_NE(nullptr, capability);
1125 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1126 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1127 }
1128
1129 /**
1130 * @tc.number : VIDEO_HWDEC_CAP_API_4700
1131 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1132 * @tc.desc : api test
1133 */
1134 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4700, TestSize.Level2)
1135 {
1136 OH_AVErrCode ret = AV_ERR_OK;
1137 OH_AVRange range;
1138 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1139 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1140 ASSERT_NE(nullptr, capability);
1141 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1142 ASSERT_EQ(AV_ERR_OK, ret);
1143 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1144 ASSERT_GE(range.minVal, 0);
1145 ASSERT_GT(range.maxVal, 0);
1146 }
1147
1148 /**
1149 * @tc.number : VIDEO_HWDEC_CAP_API_4800
1150 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1151 * @tc.desc : api test
1152 */
1153 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4800, TestSize.Level2)
1154 {
1155 OH_AVErrCode ret = AV_ERR_OK;
1156 OH_AVRange range;
1157 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1158 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1159 }
1160
1161 /**
1162 * @tc.number : VIDEO_HWDEC_CAP_API_4900
1163 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1164 * @tc.desc : api test
1165 */
1166 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4900, TestSize.Level2)
1167 {
1168 OH_AVErrCode ret = AV_ERR_OK;
1169 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1170 ASSERT_NE(nullptr, capability);
1171 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1172 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1173 }
1174
1175 /**
1176 * @tc.number : VIDEO_HWDEC_CAP_API_5000
1177 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1178 * @tc.desc : api test
1179 */
1180 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5000, TestSize.Level2)
1181 {
1182 OH_AVErrCode ret = AV_ERR_OK;
1183 OH_AVRange widthRange;
1184 OH_AVRange heightRange;
1185 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1186 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1187 ASSERT_NE(nullptr, capability);
1188 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1189 ASSERT_EQ(AV_ERR_OK, ret);
1190 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1191 ASSERT_GE(heightRange.minVal, 0);
1192 ASSERT_GT(heightRange.maxVal, 0);
1193 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1194 ASSERT_EQ(AV_ERR_OK, ret);
1195 ASSERT_GE(widthRange.minVal, 0);
1196 ASSERT_GT(widthRange.maxVal, 0);
1197 }
1198
1199 /**
1200 * @tc.number : VIDEO_HWDEC_CAP_API_1700
1201 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1202 * @tc.desc : api test
1203 */
1204 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1700, TestSize.Level2)
1205 {
1206 OH_AVErrCode ret = AV_ERR_OK;
1207 OH_AVRange widthRange;
1208 OH_AVRange heightRange;
1209 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1210 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1211 if (capability) {
1212 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1213 ASSERT_EQ(AV_ERR_OK, ret);
1214 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1215 ASSERT_GE(heightRange.minVal, 0);
1216 ASSERT_GT(heightRange.maxVal, 0);
1217 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1218 ASSERT_EQ(AV_ERR_OK, ret);
1219 ASSERT_GE(widthRange.minVal, 0);
1220 ASSERT_GT(widthRange.maxVal, 0);
1221 } else {
1222 return;
1223 }
1224 }
1225
1226 /**
1227 * @tc.number : VIDEO_HWDEC_CAP_API_5100
1228 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1229 * @tc.desc : api test
1230 */
1231 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5100, TestSize.Level2)
1232 {
1233 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1234 ASSERT_NE(nullptr, capability);
1235 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1236 }
1237
1238 /**
1239 * @tc.number : VIDEO_HWDEC_CAP_API_5200
1240 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1241 * @tc.desc : api test
1242 */
1243 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5200, TestSize.Level2)
1244 {
1245 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1246 ASSERT_NE(nullptr, capability);
1247 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1248 }
1249 /**
1250 * @tc.number : VIDEO_HWDEC_CAP_API_5300
1251 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1252 * @tc.desc : api test
1253 */
1254 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5300, TestSize.Level2)
1255 {
1256 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1257 }
1258 /**
1259 * @tc.number : VIDEO_HWDEC_CAP_API_9400
1260 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1261 * @tc.desc : api test
1262 */
1263 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_9400, TestSize.Level2)
1264 {
1265 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1266 ASSERT_NE(nullptr, capability);
1267 OH_AVRange heightRange;
1268 OH_AVRange widthRange;
1269 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoHeightRange(capability, &heightRange));
1270 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoWidthRange(capability, &widthRange));
1271 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, widthRange.maxVal + 1, heightRange.maxVal + 1));
1272 }
1273 /**
1274 * @tc.number : VIDEO_HWDEC_CAP_API_5400
1275 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1276 * @tc.desc : api test
1277 */
1278 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5400, TestSize.Level2)
1279 {
1280 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1281 ASSERT_NE(nullptr, capability);
1282 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1283 }
1284
1285 /**
1286 * @tc.number : VIDEO_HWDEC_CAP_API_5500
1287 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1288 * @tc.desc : api test
1289 */
1290 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5500, TestSize.Level2)
1291 {
1292 OH_AVErrCode ret = AV_ERR_OK;
1293 OH_AVRange range;
1294 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1295 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1296 }
1297
1298 /**
1299 * @tc.number : VIDEO_HWDEC_CAP_API_5600
1300 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1301 * @tc.desc : api test
1302 */
1303 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5600, TestSize.Level2)
1304 {
1305 OH_AVErrCode ret = AV_ERR_OK;
1306 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1307 ASSERT_NE(nullptr, capability);
1308 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1309 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1310 }
1311
1312 /**
1313 * @tc.number : VIDEO_HWDEC_CAP_API_5700
1314 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1315 * @tc.desc : api test
1316 */
1317 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5700, TestSize.Level2)
1318 {
1319 OH_AVErrCode ret = AV_ERR_OK;
1320 OH_AVRange range;
1321 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1322 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1323 ASSERT_NE(nullptr, capability);
1324 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1325 ASSERT_EQ(AV_ERR_OK, ret);
1326 ASSERT_GE(range.minVal, 0);
1327 ASSERT_GT(range.maxVal, 0);
1328 }
1329
1330 /**
1331 * @tc.number : VIDEO_HWDEC_CAP_API_1600
1332 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1333 * @tc.desc : api test
1334 */
1335 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1600, TestSize.Level2)
1336 {
1337 OH_AVErrCode ret = AV_ERR_OK;
1338 OH_AVRange range;
1339 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1340 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1341 if (capability) {
1342 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1343 ASSERT_EQ(AV_ERR_OK, ret);
1344 ASSERT_GE(range.minVal, 0);
1345 ASSERT_GT(range.maxVal, 0);
1346 } else {
1347 return;
1348 }
1349 }
1350
1351 /**
1352 * @tc.number : VIDEO_HWDEC_CAP_API_5800
1353 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1354 * @tc.desc : api test
1355 */
1356 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5800, TestSize.Level2)
1357 {
1358 OH_AVErrCode ret = AV_ERR_OK;
1359 OH_AVRange range;
1360 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1361 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1362 }
1363
1364 /**
1365 * @tc.number : VIDEO_HWDEC_CAP_API_5900
1366 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1367 * @tc.desc : api test
1368 */
1369 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5900, TestSize.Level2)
1370 {
1371 OH_AVErrCode ret = AV_ERR_OK;
1372 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1373 ASSERT_NE(nullptr, capability);
1374 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1375 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1376 }
1377
1378 /**
1379 * @tc.number : VIDEO_HWDEC_CAP_API_6000
1380 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1381 * @tc.desc : api test
1382 */
1383 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6000, TestSize.Level2)
1384 {
1385 OH_AVErrCode ret = AV_ERR_OK;
1386 OH_AVRange range;
1387 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1388 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1389 ASSERT_NE(nullptr, capability);
1390 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1391 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1392 }
1393
1394 /**
1395 * @tc.number : VIDEO_HWDEC_CAP_API_6100
1396 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1397 * @tc.desc : api test
1398 */
1399 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6100, TestSize.Level2)
1400 {
1401 OH_AVErrCode ret = AV_ERR_OK;
1402 OH_AVRange range;
1403 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1404 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1405 ASSERT_NE(nullptr, capability);
1406 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1407 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1408 }
1409
1410 /**
1411 * @tc.number : VIDEO_HWDEC_CAP_API_6200
1412 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1413 * @tc.desc : api test
1414 */
1415 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6200, TestSize.Level2)
1416 {
1417 OH_AVErrCode ret = AV_ERR_OK;
1418 OH_AVRange range;
1419 OH_AVRange heightRange;
1420 OH_AVRange widthRange;
1421 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1422 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1423 ASSERT_NE(nullptr, capability);
1424 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1425 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1426 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, heightRange.maxVal, &widthRange);
1427 cout << "minval=" << widthRange.minVal << " maxval=" << widthRange.maxVal << endl;
1428 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1429 ASSERT_EQ(AV_ERR_OK, ret);
1430 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1431 ASSERT_GE(range.minVal, 0);
1432 ASSERT_GT(range.maxVal, 0);
1433 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1434 ASSERT_EQ(AV_ERR_OK, ret);
1435 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1436 ASSERT_GE(range.minVal, 0);
1437 ASSERT_GT(range.maxVal, 0);
1438 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, widthRange.maxVal, heightRange.maxVal, &range);
1439 ASSERT_EQ(AV_ERR_OK, ret);
1440 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1441 ASSERT_GE(range.minVal, 0);
1442 ASSERT_GT(range.maxVal, 0);
1443 }
1444
1445 /**
1446 * @tc.number : VIDEO_HWDEC_CAP_API_6300
1447 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1448 * @tc.desc : api test
1449 */
1450 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6300, TestSize.Level2)
1451 {
1452 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1453 ASSERT_NE(nullptr, capability);
1454 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1455 }
1456
1457 /**
1458 * @tc.number : VIDEO_HWDEC_CAP_API_6400
1459 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1460 * @tc.desc : api test
1461 */
1462 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6400, TestSize.Level2)
1463 {
1464 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1465 ASSERT_NE(nullptr, capability);
1466 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1467 }
1468
1469 /**
1470 * @tc.number : VIDEO_HWDEC_CAP_API_6500
1471 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1472 * @tc.desc : api test
1473 */
1474 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6500, TestSize.Level2)
1475 {
1476 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1477 ASSERT_NE(nullptr, capability);
1478 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1479 }
1480
1481 /**
1482 * @tc.number : VIDEO_HWDEC_CAP_API_6600
1483 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1484 * @tc.desc : api test
1485 */
1486 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6600, TestSize.Level2)
1487 {
1488 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1489 }
1490
1491 /**
1492 * @tc.number : VIDEO_HWDEC_CAP_API_6700
1493 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1494 * @tc.desc : api test
1495 */
1496 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6700, TestSize.Level2)
1497 {
1498 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1499 ASSERT_NE(nullptr, capability);
1500 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1501 }
1502
1503 /**
1504 * @tc.number : VIDEO_HWDEC_CAP_API_6800
1505 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1506 * @tc.desc : api test
1507 */
1508 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6800, TestSize.Level2)
1509 {
1510 OH_AVErrCode ret = AV_ERR_OK;
1511 const int32_t *pixelFormat = nullptr;
1512 uint32_t pixelFormatNum = 0;
1513 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1514 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1515 }
1516
1517 /**
1518 * @tc.number : VIDEO_HWDEC_CAP_API_6900
1519 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1520 * @tc.desc : api test
1521 */
1522 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6900, TestSize.Level2)
1523 {
1524 OH_AVErrCode ret = AV_ERR_OK;
1525 uint32_t pixelFormatNum = 0;
1526 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1527 ASSERT_NE(nullptr, capability);
1528 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1529 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1530 }
1531
1532 /**
1533 * @tc.number : VIDEO_HWDEC_CAP_API_7000
1534 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1535 * @tc.desc : api test
1536 */
1537 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7000, TestSize.Level2)
1538 {
1539 OH_AVErrCode ret = AV_ERR_OK;
1540 const int32_t *pixelFormat = nullptr;
1541 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1542 ASSERT_NE(nullptr, capability);
1543 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1544 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1545 }
1546
1547 /**
1548 * @tc.number : VIDEO_HWDEC_CAP_API_7100
1549 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1550 * @tc.desc : api test
1551 */
1552 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7100, TestSize.Level2)
1553 {
1554 OH_AVErrCode ret = AV_ERR_OK;
1555 const int32_t *pixelFormat = nullptr;
1556 uint32_t pixelFormatNum = 0;
1557 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1558 ASSERT_NE(nullptr, capability);
1559 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1560 ASSERT_NE(nullptr, pixelFormat);
1561 ASSERT_GT(pixelFormatNum, 0);
1562 ASSERT_EQ(AV_ERR_OK, ret);
1563 for (int i = 0; i < pixelFormatNum; i++) {
1564 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1565 ASSERT_NE(nullptr, vdec_);
1566 format = OH_AVFormat_Create();
1567 ASSERT_NE(nullptr, format);
1568 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1569 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1570 EXPECT_GE(pixelFormat[i], 0);
1571 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1572 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1573 OH_AVFormat_Destroy(format);
1574 OH_VideoDecoder_Destroy(vdec_);
1575 }
1576 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1577 ASSERT_NE(nullptr, vdec_);
1578 format = OH_AVFormat_Create();
1579 ASSERT_NE(nullptr, format);
1580 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1581 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1582 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1583 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1584 }
1585
1586 /**
1587 * @tc.number : VIDEO_HWDEC_CAP_API_1200
1588 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1589 * @tc.desc : api test
1590 */
1591 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1200, TestSize.Level2)
1592 {
1593 OH_AVErrCode ret = AV_ERR_OK;
1594 const int32_t *pixelFormat = nullptr;
1595 uint32_t pixelFormatNum = 0;
1596 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1597 if (capability) {
1598 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1599 ASSERT_NE(nullptr, pixelFormat);
1600 ASSERT_GT(pixelFormatNum, 0);
1601 ASSERT_EQ(AV_ERR_OK, ret);
1602 for (int i = 0; i < pixelFormatNum; i++) {
1603 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1604 ASSERT_NE(nullptr, vdec_);
1605 format = OH_AVFormat_Create();
1606 ASSERT_NE(nullptr, format);
1607 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1608 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1609 EXPECT_GE(pixelFormat[i], 0);
1610 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1611 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1612 OH_AVFormat_Destroy(format);
1613 OH_VideoDecoder_Destroy(vdec_);
1614 }
1615 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1616 ASSERT_NE(nullptr, vdec_);
1617 format = OH_AVFormat_Create();
1618 ASSERT_NE(nullptr, format);
1619 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1620 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1621 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1622 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1623 } else {
1624 return;
1625 }
1626 }
1627
1628 /**
1629 * @tc.number : VIDEO_HWDEC_CAP_API_7200
1630 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1631 * @tc.desc : api test
1632 */
1633 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7200, TestSize.Level2)
1634 {
1635 OH_AVErrCode ret = AV_ERR_OK;
1636 const int32_t *profiles = nullptr;
1637 uint32_t profileNum = 0;
1638 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
1639 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1640 }
1641
1642 /**
1643 * @tc.number : VIDEO_HWDEC_CAP_API_7300
1644 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1645 * @tc.desc : api test
1646 */
1647 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7300, TestSize.Level2)
1648 {
1649 OH_AVErrCode ret = AV_ERR_OK;
1650 uint32_t profileNum = 0;
1651 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1652 ASSERT_NE(nullptr, capability);
1653 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
1654 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1655 }
1656
1657 /**
1658 * @tc.number : VIDEO_HWDEC_CAP_API_7400
1659 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1660 * @tc.desc : api test
1661 */
1662 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7400, TestSize.Level2)
1663 {
1664 OH_AVErrCode ret = AV_ERR_OK;
1665 const int32_t *profiles = nullptr;
1666 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1667 ASSERT_NE(nullptr, capability);
1668 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
1669 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1670 }
1671
1672 /**
1673 * @tc.number : VIDEO_HWDEC_CAP_API_7500
1674 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1675 * @tc.desc : api test
1676 */
1677 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7500, TestSize.Level2)
1678 {
1679 OH_AVErrCode ret = AV_ERR_OK;
1680 const int32_t *profiles = nullptr;
1681 uint32_t profileNum = 0;
1682 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1683 ASSERT_NE(nullptr, capability);
1684 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1685 ASSERT_EQ(AV_ERR_OK, ret);
1686 ASSERT_GT(profileNum, 0);
1687 ASSERT_NE(nullptr, profiles);
1688 for (int i = 0; i < profileNum; i++) {
1689 EXPECT_GE(profiles[i], 0);
1690 }
1691 }
1692
1693 /**
1694 * @tc.number : VIDEO_HWDEC_CAP_API_1300
1695 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1696 * @tc.desc : api test
1697 */
1698 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1300, TestSize.Level2)
1699 {
1700 OH_AVErrCode ret = AV_ERR_OK;
1701 const int32_t *profiles = nullptr;
1702 uint32_t profileNum = 0;
1703 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1704 if (capability) {
1705 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1706 ASSERT_EQ(AV_ERR_OK, ret);
1707 ASSERT_GT(profileNum, 0);
1708 ASSERT_NE(nullptr, profiles);
1709 for (int i = 0; i < profileNum; i++) {
1710 EXPECT_GE(profiles[i], 0);
1711 }
1712 } else {
1713 return;
1714 }
1715
1716 }
1717
1718 /**
1719 * @tc.number : VIDEO_HWDEC_CAP_API_7600
1720 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1721 * @tc.desc : api test
1722 */
1723 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7600, TestSize.Level2)
1724 {
1725 OH_AVErrCode ret = AV_ERR_OK;
1726 const int32_t *levels = nullptr;
1727 uint32_t levelNum = 0;
1728 ret = OH_AVCapability_GetSupportedLevelsForProfile(nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
1729 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1730 }
1731
1732 /**
1733 * @tc.number : VIDEO_HWDEC_CAP_API_7700
1734 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1735 * @tc.desc : api test
1736 */
1737 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7700, TestSize.Level2)
1738 {
1739 OH_AVErrCode ret = AV_ERR_OK;
1740 const int32_t *levels = nullptr;
1741 uint32_t levelNum = 0;
1742 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1743 ASSERT_NE(nullptr, capability);
1744 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
1745 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1746 }
1747
1748 /**
1749 * @tc.number : VIDEO_HWDEC_CAP_API_7800
1750 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1751 * @tc.desc : api test
1752 */
1753 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7800, TestSize.Level2)
1754 {
1755 OH_AVErrCode ret = AV_ERR_OK;
1756 uint32_t levelNum = 0;
1757 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1758 ASSERT_NE(nullptr, capability);
1759 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
1760 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1761 }
1762
1763 /**
1764 * @tc.number : VIDEO_HWDEC_CAP_API_7900
1765 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1766 * @tc.desc : api test
1767 */
1768 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7900, TestSize.Level2)
1769 {
1770 OH_AVErrCode ret = AV_ERR_OK;
1771 const int32_t *levels = nullptr;
1772 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1773 ASSERT_NE(nullptr, capability);
1774 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, nullptr);
1775 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1776 }
1777
1778 /**
1779 * @tc.number : VIDEO_HWDEC_CAP_API_8000
1780 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1781 * @tc.desc : api test
1782 */
1783 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8000, TestSize.Level2)
1784 {
1785 OH_AVErrCode ret = AV_ERR_OK;
1786 const int32_t *levels = nullptr;
1787 uint32_t levelNum = 0;
1788 const int32_t *profiles = nullptr;
1789 uint32_t profileNum = 0;
1790 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1791 ASSERT_NE(nullptr, capability);
1792 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1793 ASSERT_EQ(AV_ERR_OK, ret);
1794 ASSERT_GT(profileNum, 0);
1795 ASSERT_NE(nullptr, profiles);
1796 for (int i = 0; i < profileNum; i++) {
1797 EXPECT_GE(profiles[i], 0);
1798 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
1799 ASSERT_EQ(AV_ERR_OK, ret);
1800 ASSERT_NE(nullptr, levels);
1801 EXPECT_GT(levelNum, 0);
1802 for (int j = 0; j < levelNum; j++) {
1803 EXPECT_GE(levels[j], 0);
1804 }
1805 }
1806 }
1807
1808 /**
1809 * @tc.number : VIDEO_HWDEC_CAP_API_1400
1810 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1811 * @tc.desc : api test
1812 */
1813 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1400, TestSize.Level2)
1814 {
1815 OH_AVErrCode ret = AV_ERR_OK;
1816 const int32_t *levels = nullptr;
1817 uint32_t levelNum = 0;
1818 uint32_t profileNum = 0;
1819 const int32_t *profiles = nullptr;
1820 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1821 if (capability) {
1822 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1823 ASSERT_EQ(AV_ERR_OK, ret);
1824 ASSERT_GT(profileNum, 0);
1825 ASSERT_NE(nullptr, profiles);
1826 for (int i = 0; i < profileNum; i++) {
1827 ASSERT_GE(profiles[i], 0);
1828 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
1829 ASSERT_EQ(AV_ERR_OK, ret);
1830 ASSERT_NE(nullptr, levels);
1831 ASSERT_GT(levelNum, 0);
1832 for (int j = 0; j < levelNum; j++) {
1833 EXPECT_GE(levels[j], 0);
1834 }
1835 }
1836 } else {
1837 return;
1838 }
1839
1840 }
1841
1842 /**
1843 * @tc.number : VIDEO_HWDEC_CAP_API_8100
1844 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1845 * @tc.desc : api test
1846 */
1847 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8100, TestSize.Level2)
1848 {
1849 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(nullptr, AVC_PROFILE_BASELINE, 1));
1850 }
1851
1852 /**
1853 * @tc.number : VIDEO_HWDEC_CAP_API_8200
1854 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1855 * @tc.desc : api test
1856 */
1857 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8200, TestSize.Level2)
1858 {
1859 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1860 ASSERT_NE(nullptr, capability);
1861 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
1862 }
1863
1864 /**
1865 * @tc.number : VIDEO_HWDEC_CAP_API_8300
1866 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1867 * @tc.desc : api test
1868 */
1869 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8300, TestSize.Level2)
1870 {
1871 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1872 ASSERT_NE(nullptr, capability);
1873 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
1874 }
1875
1876 /**
1877 * @tc.number : VIDEO_HWDEC_ATTIME_API_0010
1878 * @tc.name : OH_VideoDecoder_RenderOutputBufferAtTime use renderTimestampNs of < 0
1879 * @tc.desc : api test
1880 */
1881 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ATTIME_API_0010, TestSize.Level1)
1882 {
1883 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1884 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
1885 vDecSample->INP_DIR = INP_DIR_720_30;
1886 vDecSample->SF_OUTPUT = true;
1887 vDecSample->DEFAULT_WIDTH = 1280;
1888 vDecSample->DEFAULT_HEIGHT = 720;
1889 vDecSample->DEFAULT_FRAME_RATE = 30;
1890 vDecSample->rsAtTime = true;
1891 vDecSample->isAPI = true;
1892 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
1893 vDecSample->WaitForEOS();
1894 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->errCount);
1895 }
1896
1897 /**
1898 * @tc.number : VIDEO_DECODE_SYNC_API_0010
1899 * @tc.name : VIDEO_DECODE_SYNC_API_0010
1900 * @tc.desc : api test
1901 */
1902 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0010, TestSize.Level2)
1903 {
1904 uint32_t index;
1905 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_QueryInputBuffer(nullptr, &index, -1));
1906 }
1907
1908 /**
1909 * @tc.number : VIDEO_DECODE_SYNC_API_0020
1910 * @tc.name : VIDEO_DECODE_SYNC_API_0020
1911 * @tc.desc : api test
1912 */
1913 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0020, TestSize.Level2)
1914 {
1915 uint32_t index;
1916 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1917 ASSERT_NE(nullptr, vdec_);
1918 format = OH_AVFormat_Create();
1919 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1920 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1921 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_ENABLE_SYNC_MODE, 1);
1922 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1923 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Prepare(vdec_));
1924 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1925 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_QueryInputBuffer(vdec_, &index, INT64_MAX));
1926 }
1927
1928 /**
1929 * @tc.number : VIDEO_DECODE_SYNC_API_0030
1930 * @tc.name : VIDEO_DECODE_SYNC_API_0030
1931 * @tc.desc : api test
1932 */
1933 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0030, TestSize.Level2)
1934 {
1935 uint32_t index;
1936 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1937 ASSERT_NE(nullptr, vdec_);
1938 format = OH_AVFormat_Create();
1939 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1940 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1941 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_ENABLE_SYNC_MODE, 1);
1942 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1943 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Prepare(vdec_));
1944 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1945 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_QueryInputBuffer(vdec_, &index, INT64_MIN));
1946 }
1947
1948 /**
1949 * @tc.number : VIDEO_DECODE_SYNC_API_0040
1950 * @tc.name : VIDEO_DECODE_SYNC_API_0040
1951 * @tc.desc : api test
1952 */
1953 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0040, TestSize.Level2)
1954 {
1955 ASSERT_EQ(nullptr, OH_VideoDecoder_GetInputBuffer(nullptr, 1));
1956 }
1957
1958 /**
1959 * @tc.number : VIDEO_DECODE_SYNC_API_0050
1960 * @tc.name : VIDEO_DECODE_SYNC_API_0050
1961 * @tc.desc : api test
1962 */
1963 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0050, TestSize.Level2)
1964 {
1965 uint32_t index;
1966 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_QueryOutputBuffer(nullptr, &index, -1));
1967 }
1968
1969 /**
1970 * @tc.number : VIDEO_DECODE_SYNC_API_0060
1971 * @tc.name : VIDEO_DECODE_SYNC_API_0060
1972 * @tc.desc : api test
1973 */
1974 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0060, TestSize.Level2)
1975 {
1976 auto vDecSample = make_shared<VDecAPI11Sample>();
1977 vDecSample->enbleSyncMode = 1;
1978 vDecSample->syncOutputWaitTime = INT64_MAX;
1979 vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
1980 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1981 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1982 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1983 vDecSample->WaitForEOS();
1984 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1985 }
1986
1987 /**
1988 * @tc.number : VIDEO_DECODE_SYNC_API_0070
1989 * @tc.name : VIDEO_DECODE_SYNC_API_0070
1990 * @tc.desc : api test
1991 */
1992 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0070, TestSize.Level2)
1993 {
1994 auto vDecSample = make_shared<VDecAPI11Sample>();
1995 vDecSample->enbleSyncMode = 1;
1996 vDecSample->syncOutputWaitTime = INT64_MIN;
1997 vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
1998 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
1999 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
2000 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
2001 vDecSample->WaitForEOS();
2002 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
2003 }
2004
2005 /**
2006 * @tc.number : VIDEO_DECODE_SYNC_API_0080
2007 * @tc.name : VIDEO_DECODE_SYNC_API_0080
2008 * @tc.desc : api test
2009 */
2010 HWTEST_F(HwdecApiNdkTest, VIDEO_DECODE_SYNC_API_0080, TestSize.Level2)
2011 {
2012 ASSERT_EQ(nullptr, OH_VideoDecoder_GetOutputBuffer(nullptr, 1));
2013 }
2014 } // namespace