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_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 cb_.onNeedOutputData = VdecOutputDataReady;
627 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, static_cast<void *>(signal_)));
628 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
629 for (int i = 0; i < 2; i++) {
630 unique_lock<mutex> lock(signal_->inMutex_);
__anon7dea6e900302() 631 signal_->inCond_.wait(lock, []() { return signal_->inIdxQueue_.size() > 0; });
632 uint32_t index = signal_->inIdxQueue_.front();
633 OH_AVCodecBufferAttr attr;
634 attr.pts = 0;
635 attr.size = 0;
636 attr.offset = 0;
637 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
638 cout << "OH_VideoDecoder_PushInputData index:" << index << endl;
639 if (i == 0) {
640 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_PushInputData(vdec_, index, attr));
641 } else {
642 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
643 }
644 }
645 OH_VideoDecoder_Destroy(vdec_);
646 vdec_ = nullptr;
647 signal_->inIdxQueue_.pop();
648 }
649
650 /**
651 * @tc.number : VIDEO_HWDEC_API_0700
652 * @tc.name : create configure start flush flush
653 * @tc.desc : function test
654 */
655 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0700, TestSize.Level2)
656 {
657 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
658 ASSERT_NE(NULL, vdec_);
659
660 format = OH_AVFormat_Create();
661 ASSERT_NE(NULL, format);
662
663 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
664 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
665 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
666 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
667
668 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
669 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
670 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
671 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
672 }
673
674 /**
675 * @tc.number : VIDEO_HWDEC_API_0800
676 * @tc.name : create configure start stop release release
677 * @tc.desc : function test
678 */
679 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0800, TestSize.Level2)
680 {
681 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
682 ASSERT_NE(NULL, vdec_);
683
684 format = OH_AVFormat_Create();
685 ASSERT_NE(NULL, format);
686
687 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
688 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
689 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
690 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
691
692 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
693 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
694 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
695 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
696 vdec_ = nullptr;
697 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
698 }
699
700 /**
701 * @tc.number : VIDEO_HWDEC_API_0900
702 * @tc.name : create create
703 * @tc.desc : function test
704 */
705 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0900, TestSize.Level2)
706 {
707 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
708 ASSERT_NE(vdec_, NULL);
709 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
710 ASSERT_NE(vdec_2, NULL);
711 OH_VideoDecoder_Destroy(vdec_2);
712 vdec_2 = nullptr;
713 }
714
715 /**
716 * @tc.number : VIDEO_HWDEC_API_1000
717 * @tc.name : repeat OH_VideoDecoder_SetCallback
718 * @tc.desc : function test
719 */
720 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1000, TestSize.Level2)
721 {
722 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
723 OH_AVCodecAsyncCallback cb_;
724 cb_.onError = VdecError;
725 cb_.onStreamChanged = VdecFormatChanged;
726 cb_.onNeedInputData = VdecInputDataReady;
727 cb_.onNeedOutputData = VdecOutputDataReady;
728 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
729 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
730 }
731
732 /**
733 * @tc.number : VIDEO_HWDEC_API_1100
734 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
735 * @tc.desc : function test
736 */
737 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1100, TestSize.Level2)
738 {
739 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
740 format = OH_VideoDecoder_GetOutputDescription(vdec_);
741 ASSERT_NE(NULL, format);
742 format = OH_VideoDecoder_GetOutputDescription(vdec_);
743 ASSERT_NE(NULL, format);
744 }
745
746 /**
747 * @tc.number : VIDEO_HWDEC_API_1200
748 * @tc.name : repeat OH_VideoDecoder_SetParameter
749 * @tc.desc : function test
750 */
751 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1200, TestSize.Level2)
752 {
753 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
754 ASSERT_NE(NULL, vdec_);
755
756 format = OH_AVFormat_Create();
757 ASSERT_NE(NULL, format);
758
759 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
760 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
761 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
762 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
763
764 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
765 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
766 }
767
768 /**
769 * @tc.number : VIDEO_HWDEC_CAP_API_0100
770 * @tc.name : OH_AVCodec_GetCapability
771 * @tc.desc : function test
772 */
773 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0100, TestSize.Level2)
774 {
775 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false);
776 ASSERT_NE(cap, nullptr);
777 }
778
779 /**
780 * @tc.number : VIDEO_HWDEC_CAP_API_0110
781 * @tc.name : OH_AVCodec_GetCapability
782 * @tc.desc : function test
783 */
784 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0110, TestSize.Level2)
785 {
786 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false);
787 ASSERT_NE(cap, nullptr);
788 }
789
790 /**
791 * @tc.number : VIDEO_HWDEC_CAP_API_0200
792 * @tc.name : OH_AVCodec_GetCapability
793 * @tc.desc : function test
794 */
795 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0200, TestSize.Level2)
796 {
797 cap = OH_AVCodec_GetCapability(nullptr, false);
798 ASSERT_EQ(cap, nullptr);
799 }
800
801 /**
802 * @tc.number : VIDEO_HWDEC_CAP_API_0300
803 * @tc.name : OH_AVCodec_GetCapability
804 * @tc.desc : function test
805 */
806 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0300, TestSize.Level2)
807 {
808 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
809 ASSERT_NE(cap, nullptr);
810 }
811
812 /**
813 * @tc.number : VIDEO_HWDEC_CAP_API_0400
814 * @tc.name : OH_AVCodec_GetCapability
815 * @tc.desc : function test
816 */
817 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0400, TestSize.Level2)
818 {
819 cap = OH_AVCodec_GetCapabilityByCategory(nullptr, false, HARDWARE);
820 ASSERT_EQ(cap, nullptr);
821 }
822
823 /**
824 * @tc.number : VIDEO_HWDEC_CAP_API_0500
825 * @tc.name : OH_AVCodec_GetCapability
826 * @tc.desc : function test
827 */
828 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0500, TestSize.Level2)
829 {
830 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
831 ASSERT_NE(cap, nullptr);
832 ASSERT_TRUE(OH_AVCapability_IsHardware(cap));
833 }
834
835 /**
836 * @tc.number : VIDEO_HWDEC_CAP_API_0510
837 * @tc.name : OH_AVCodec_GetCapability hevc
838 * @tc.desc : function test
839 */
840 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0510, TestSize.Level2)
841 {
842 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
843 ASSERT_NE(cap, nullptr);
844 ASSERT_TRUE(OH_AVCapability_IsHardware(cap));
845 }
846
847 /**
848 * @tc.number : VIDEO_HWDEC_CAP_API_0600
849 * @tc.name : OH_AVCodec_GetCapability
850 * @tc.desc : function test
851 */
852 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0600, TestSize.Level2)
853 {
854 ASSERT_FALSE(OH_AVCapability_IsHardware(nullptr));
855 }
856
857 /**
858 * @tc.number : VIDEO_HWDEC_CAP_API_0700
859 * @tc.name : OH_AVCodec_GetCapability
860 * @tc.desc : function test
861 */
862 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0700, TestSize.Level2)
863 {
864 ASSERT_EQ(0, OH_AVCapability_GetMaxSupportedInstances(nullptr));
865 }
866
867 /**
868 * @tc.number : VIDEO_HWDEC_CAP_API_0800
869 * @tc.name : OH_AVCodec_GetCapability
870 * @tc.desc : function test
871 */
872 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0800, TestSize.Level2)
873 {
874 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
875 ASSERT_NE(cap, nullptr);
876 string codec_name = OH_AVCapability_GetName(cap);
877 if (codec_name == "OMX.hisi.video.decoder.avc") {
878 ASSERT_EQ(30, OH_AVCapability_GetMaxSupportedInstances(cap));
879 } else {
880 ASSERT_EQ(6, OH_AVCapability_GetMaxSupportedInstances(cap));
881 }
882 }
883
884 /**
885 * @tc.number : VIDEO_HWDEC_CAP_API_0810
886 * @tc.name : OH_AVCodec_GetCapability
887 * @tc.desc : function test
888 */
889 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0810, TestSize.Level2)
890 {
891 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
892 ASSERT_NE(cap, nullptr);
893 string codec_name = OH_AVCapability_GetName(cap);
894 if (codec_name == "OMX.hisi.video.decoder.hevc") {
895 ASSERT_EQ(30, OH_AVCapability_GetMaxSupportedInstances(cap));
896 } else {
897 ASSERT_EQ(6, OH_AVCapability_GetMaxSupportedInstances(cap));
898 }
899 }
900
901 /**
902 * @tc.number : VIDEO_HWDEC_CAP_API_0900
903 * @tc.name : OH_AVCodec_GetCapability
904 * @tc.desc : function test
905 */
906 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0900, TestSize.Level2)
907 {
908 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
909 ASSERT_NE(cap, nullptr);
910 ASSERT_EQ(g_codecName, OH_AVCapability_GetName(cap));
911 }
912
913 /**
914 * @tc.number : VIDEO_HWDEC_CAP_API_1000
915 * @tc.name : OH_AVCodec_GetCapability
916 * @tc.desc : function test
917 */
918 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1000, TestSize.Level2)
919 {
920 const char *name = OH_AVCapability_GetName(nullptr);
921 ASSERT_NE(name, nullptr);
922 ASSERT_EQ(strlen(name), 0);
923 }
924
925 /**
926 * @tc.number : VIDEO_HWDEC_CAP_API_3100
927 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
928 * @tc.desc : api test
929 */
930 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3100, TestSize.Level2)
931 {
932 OH_AVErrCode ret = AV_ERR_OK;
933 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
934 ASSERT_NE(nullptr, capability);
935 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
936 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
937 }
938
939 /**
940 * @tc.number : VIDEO_HWDEC_CAP_API_3200
941 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
942 * @tc.desc : api test
943 */
944 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3200, TestSize.Level2)
945 {
946 OH_AVErrCode ret = AV_ERR_OK;
947 int32_t alignment = 0;
948 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
949 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
950 }
951
952 /**
953 * @tc.number : VIDEO_HWDEC_CAP_API_3300
954 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
955 * @tc.desc : api test
956 */
957 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3300, TestSize.Level2)
958 {
959 OH_AVErrCode ret = AV_ERR_OK;
960 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
961 ASSERT_NE(nullptr, capability);
962 int32_t alignment = 0;
963 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
964 cout << "WidthAlignment " << alignment << endl;
965 ASSERT_EQ(AV_ERR_OK, ret);
966 ASSERT_GE(alignment, 0);
967 }
968 /**
969 * @tc.number : VIDEO_HWDEC_CAP_API_3310
970 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
971 * @tc.desc : api test
972 */
973 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3310, TestSize.Level2)
974 {
975 OH_AVErrCode ret = AV_ERR_OK;
976 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
977 ASSERT_NE(nullptr, capability);
978 int32_t alignment = 0;
979 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
980 cout << "WidthAlignment " << alignment << endl;
981 ASSERT_EQ(AV_ERR_OK, ret);
982 ASSERT_GE(alignment, 0);
983 }
984
985 /**
986 * @tc.number : VIDEO_HWDEC_CAP_API_3400
987 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
988 * @tc.desc : api test
989 */
990 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3400, TestSize.Level2)
991 {
992 OH_AVErrCode ret = AV_ERR_OK;
993 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
994 ASSERT_NE(nullptr, capability);
995 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
996 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
997 }
998
999 /**
1000 * @tc.number : VIDEO_HWDEC_CAP_API_3500
1001 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1002 * @tc.desc : api test
1003 */
1004 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3500, TestSize.Level2)
1005 {
1006 OH_AVErrCode ret = AV_ERR_OK;
1007 int32_t alignment = 0;
1008 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
1009 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1010 }
1011
1012 /**
1013 * @tc.number : VIDEO_HWDEC_CAP_API_3600
1014 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
1015 * @tc.desc : api test
1016 */
1017 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3600, TestSize.Level2)
1018 {
1019 OH_AVErrCode ret = AV_ERR_OK;
1020 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1021 ASSERT_NE(nullptr, capability);
1022 int32_t alignment = 0;
1023 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
1024 cout << "HeightAlignment " << alignment << endl;
1025 ASSERT_EQ(AV_ERR_OK, ret);
1026 ASSERT_GE(alignment, 0);
1027 }
1028
1029 /**
1030 * @tc.number : VIDEO_HWDEC_CAP_API_3610
1031 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
1032 * @tc.desc : api test
1033 */
1034 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3610, TestSize.Level2)
1035 {
1036 OH_AVErrCode ret = AV_ERR_OK;
1037 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1038 ASSERT_NE(nullptr, capability);
1039 int32_t alignment = 0;
1040 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
1041 cout << "HeightAlignment " << alignment << endl;
1042 ASSERT_EQ(AV_ERR_OK, ret);
1043 ASSERT_GE(alignment, 0);
1044 }
1045
1046 /**
1047 * @tc.number : VIDEO_HWDEC_CAP_API_3700
1048 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1049 * @tc.desc : api test
1050 */
1051 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3700, TestSize.Level2)
1052 {
1053 OH_AVErrCode ret = AV_ERR_OK;
1054 OH_AVRange range;
1055 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1056 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1057 ASSERT_NE(nullptr, capability);
1058 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range);
1059 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1060 }
1061
1062 /**
1063 * @tc.number : VIDEO_HWDEC_CAP_API_3800
1064 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1065 * @tc.desc : api test
1066 */
1067 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3800, TestSize.Level2)
1068 {
1069 OH_AVErrCode ret = AV_ERR_OK;
1070 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1071 ASSERT_NE(nullptr, capability);
1072 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, nullptr);
1073 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1074 }
1075
1076 /**
1077 * @tc.number : VIDEO_HWDEC_CAP_API_3900
1078 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1079 * @tc.desc : api test
1080 */
1081 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3900, TestSize.Level2)
1082 {
1083 OH_AVErrCode ret = AV_ERR_OK;
1084 OH_AVRange range;
1085 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1086 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1087 ASSERT_NE(nullptr, capability);
1088 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
1089 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1090 }
1091
1092 /**
1093 * @tc.number : VIDEO_HWDEC_CAP_API_4000
1094 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1095 * @tc.desc : api test
1096 */
1097 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4000, TestSize.Level2)
1098 {
1099 OH_AVErrCode ret = AV_ERR_OK;
1100 OH_AVRange range;
1101 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1102 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1103 ASSERT_NE(nullptr, capability);
1104 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
1105 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1106 ASSERT_EQ(AV_ERR_OK, ret);
1107 ASSERT_GE(range.minVal, 0);
1108 ASSERT_GT(range.maxVal, 0);
1109 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1110 ASSERT_NE(nullptr, vdec_);
1111 format = OH_AVFormat_Create();
1112 ASSERT_NE(nullptr, format);
1113 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1114 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1115 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1116 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1117 OH_VideoDecoder_Destroy(vdec_);
1118 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1119 ASSERT_NE(nullptr, vdec_);
1120 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1121 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1122 }
1123
1124 /**
1125 * @tc.number : VIDEO_HWDEC_CAP_API_4010
1126 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1127 * @tc.desc : api test //ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1128 */
1129 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4010, TestSize.Level2)
1130 {
1131 OH_AVErrCode ret = AV_ERR_OK;
1132 OH_AVRange range;
1133 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1134 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1135 ASSERT_NE(nullptr, capability);
1136 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
1137 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1138 ASSERT_EQ(AV_ERR_OK, ret);
1139 ASSERT_GE(range.minVal, 0);
1140 ASSERT_GT(range.maxVal, 0);
1141 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1142 ASSERT_NE(nullptr, vdec_);
1143 format = OH_AVFormat_Create();
1144 ASSERT_NE(nullptr, format);
1145 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1146 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1147 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1148 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1149 OH_VideoDecoder_Destroy(vdec_);
1150 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1151 ASSERT_NE(nullptr, vdec_);
1152 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1153 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1154 }
1155
1156 /**
1157 * @tc.number : VIDEO_HWDEC_CAP_API_4100
1158 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1159 * @tc.desc : api test
1160 */
1161 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4100, TestSize.Level2)
1162 {
1163 OH_AVErrCode ret = AV_ERR_OK;
1164 OH_AVRange range;
1165 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1166 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1167 ASSERT_NE(nullptr, capability);
1168 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1169 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1170 }
1171
1172 /**
1173 * @tc.number : VIDEO_HWDEC_CAP_API_4200
1174 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1175 * @tc.desc : api test
1176 */
1177 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4200, TestSize.Level2)
1178 {
1179 OH_AVErrCode ret = AV_ERR_OK;
1180 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1181 ASSERT_NE(nullptr, capability);
1182 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1183 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1184 }
1185
1186 /**
1187 * @tc.number : VIDEO_HWDEC_CAP_API_4300
1188 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1189 * @tc.desc : api test
1190 */
1191 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4300, TestSize.Level2)
1192 {
1193 OH_AVErrCode ret = AV_ERR_OK;
1194 OH_AVRange range;
1195 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1196 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1197 ASSERT_NE(nullptr, capability);
1198 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1199 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1200 }
1201
1202 /**
1203 * @tc.number : VIDEO_HWDEC_CAP_API_4400
1204 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1205 * @tc.desc : api test
1206 */
1207 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4400, TestSize.Level2)
1208 {
1209 OH_AVErrCode ret = AV_ERR_OK;
1210 OH_AVRange range;
1211 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1212 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1213 ASSERT_NE(nullptr, capability);
1214 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1215 ASSERT_EQ(AV_ERR_OK, ret);
1216 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1217 ASSERT_GE(range.minVal, 0);
1218 ASSERT_GT(range.maxVal, 0);
1219 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1220 ASSERT_NE(nullptr, vdec_);
1221 format = OH_AVFormat_Create();
1222 ASSERT_NE(nullptr, format);
1223 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1224 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1225 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1226 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1227 OH_VideoDecoder_Destroy(vdec_);
1228 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1229 ASSERT_NE(nullptr, vdec_);
1230 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1231 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1232 }
1233
1234 /**
1235 * @tc.number : VIDEO_HWDEC_CAP_API_4410
1236 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1237 * @tc.desc : api test
1238 */
1239 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4410, TestSize.Level2)
1240 {
1241 OH_AVErrCode ret = AV_ERR_OK;
1242 OH_AVRange range;
1243 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1244 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1245 ASSERT_NE(nullptr, capability);
1246 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1247 ASSERT_EQ(AV_ERR_OK, ret);
1248 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1249 ASSERT_GE(range.minVal, 0);
1250 ASSERT_GT(range.maxVal, 0);
1251 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1252 ASSERT_NE(nullptr, vdec_);
1253 format = OH_AVFormat_Create();
1254 ASSERT_NE(nullptr, format);
1255 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1256 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1257 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1258 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1259 OH_VideoDecoder_Destroy(vdec_);
1260 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1261 ASSERT_NE(nullptr, vdec_);
1262 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1263 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1264 }
1265
1266 /**
1267 * @tc.number : VIDEO_HWDEC_CAP_API_4500
1268 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1269 * @tc.desc : api test
1270 */
1271 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4500, TestSize.Level2)
1272 {
1273 OH_AVErrCode ret = AV_ERR_OK;
1274 OH_AVRange range;
1275 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1276 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1277 }
1278
1279 /**
1280 * @tc.number : VIDEO_HWDEC_CAP_API_4600
1281 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1282 * @tc.desc : api test
1283 */
1284 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4600, TestSize.Level2)
1285 {
1286 OH_AVErrCode ret = AV_ERR_OK;
1287 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1288 ASSERT_NE(nullptr, capability);
1289 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1290 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1291 }
1292
1293 /**
1294 * @tc.number : VIDEO_HWDEC_CAP_API_4700
1295 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1296 * @tc.desc : api test
1297 */
1298 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4700, TestSize.Level2)
1299 {
1300 OH_AVErrCode ret = AV_ERR_OK;
1301 OH_AVRange range;
1302 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1303 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1304 ASSERT_NE(nullptr, capability);
1305 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1306 ASSERT_EQ(AV_ERR_OK, ret);
1307 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1308 ASSERT_GE(range.minVal, 0);
1309 ASSERT_GT(range.maxVal, 0);
1310 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1311 ASSERT_NE(nullptr, vdec_);
1312 format = OH_AVFormat_Create();
1313 ASSERT_NE(nullptr, format);
1314 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1315 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1316 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1317 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1318 OH_VideoDecoder_Destroy(vdec_);
1319 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1320 ASSERT_NE(nullptr, vdec_);
1321 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1322 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1323 }
1324
1325 /**
1326 * @tc.number : VIDEO_HWDEC_CAP_API_4710
1327 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1328 * @tc.desc : api test
1329 */
1330 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4710, TestSize.Level2)
1331 {
1332 OH_AVErrCode ret = AV_ERR_OK;
1333 OH_AVRange range;
1334 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1335 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1336 ASSERT_NE(nullptr, capability);
1337 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1338 ASSERT_EQ(AV_ERR_OK, ret);
1339 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1340 ASSERT_GE(range.minVal, 0);
1341 ASSERT_GT(range.maxVal, 0);
1342 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1343 ASSERT_NE(nullptr, vdec_);
1344 format = OH_AVFormat_Create();
1345 ASSERT_NE(nullptr, format);
1346 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1347 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1348 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1349 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1350 OH_VideoDecoder_Destroy(vdec_);
1351 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1352 ASSERT_NE(nullptr, vdec_);
1353 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1354 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1355 }
1356
1357 /**
1358 * @tc.number : VIDEO_HWDEC_CAP_API_4800
1359 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1360 * @tc.desc : api test
1361 */
1362 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4800, TestSize.Level2)
1363 {
1364 OH_AVErrCode ret = AV_ERR_OK;
1365 OH_AVRange range;
1366 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1367 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1368 }
1369
1370 /**
1371 * @tc.number : VIDEO_HWDEC_CAP_API_4900
1372 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1373 * @tc.desc : api test
1374 */
1375 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4900, TestSize.Level2)
1376 {
1377 OH_AVErrCode ret = AV_ERR_OK;
1378 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1379 ASSERT_NE(nullptr, capability);
1380 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1381 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1382 }
1383
1384 /**
1385 * @tc.number : VIDEO_HWDEC_CAP_API_5000
1386 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1387 * @tc.desc : api test
1388 */
1389 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5000, TestSize.Level2)
1390 {
1391 OH_AVErrCode ret = AV_ERR_OK;
1392 OH_AVRange widthRange;
1393 OH_AVRange heightRange;
1394 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1395 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1396 ASSERT_NE(nullptr, capability);
1397 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1398 ASSERT_EQ(AV_ERR_OK, ret);
1399 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1400 ASSERT_GE(heightRange.minVal, 0);
1401 ASSERT_GT(heightRange.maxVal, 0);
1402 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1403 ASSERT_NE(nullptr, vdec_);
1404 format = OH_AVFormat_Create();
1405 ASSERT_NE(nullptr, format);
1406 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1407 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1408 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1409 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1410 OH_VideoDecoder_Destroy(vdec_);
1411 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1412 ASSERT_NE(nullptr, vdec_);
1413 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1414 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1415 }
1416
1417 /**
1418 * @tc.number : VIDEO_HWDEC_CAP_API_1700
1419 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1420 * @tc.desc : api test
1421 */
1422 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1700, TestSize.Level2)
1423 {
1424 OH_AVErrCode ret = AV_ERR_OK;
1425 OH_AVRange widthRange;
1426 OH_AVRange heightRange;
1427 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1428 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1429 ASSERT_NE(nullptr, capability);
1430 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1431 ASSERT_EQ(AV_ERR_OK, ret);
1432 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1433 ASSERT_GE(heightRange.minVal, 0);
1434 ASSERT_GT(heightRange.maxVal, 0);
1435 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1436 ASSERT_EQ(AV_ERR_OK, ret);
1437 ASSERT_GE(widthRange.minVal, 0);
1438 ASSERT_GT(widthRange.maxVal, 0);
1439 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1440 ASSERT_NE(nullptr, vdec_);
1441 format = OH_AVFormat_Create();
1442 ASSERT_NE(nullptr, format);
1443 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1444 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1445 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1446 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1447 OH_VideoDecoder_Destroy(vdec_);
1448 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1449 ASSERT_NE(nullptr, vdec_);
1450 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1451 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1452 }
1453
1454 /**
1455 * @tc.number : VIDEO_HWDEC_CAP_API_5100
1456 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1457 * @tc.desc : api test
1458 */
1459 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5100, TestSize.Level2)
1460 {
1461 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1462 ASSERT_NE(nullptr, capability);
1463 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1464 }
1465
1466 /**
1467 * @tc.number : VIDEO_HWDEC_CAP_API_5200
1468 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1469 * @tc.desc : api test
1470 */
1471 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5200, TestSize.Level2)
1472 {
1473 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1474 ASSERT_NE(nullptr, capability);
1475 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1476 }
1477 /**
1478 * @tc.number : VIDEO_HWDEC_CAP_API_5300
1479 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1480 * @tc.desc : api test
1481 */
1482 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5300, TestSize.Level2)
1483 {
1484 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1485 }
1486 /**
1487 * @tc.number : VIDEO_HWDEC_CAP_API_9400
1488 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1489 * @tc.desc : api test
1490 */
1491 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_9400, TestSize.Level2)
1492 {
1493 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1494 ASSERT_NE(nullptr, capability);
1495 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 7680, 4320));
1496 }
1497 /**
1498 * @tc.number : VIDEO_HWDEC_CAP_API_5400
1499 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1500 * @tc.desc : api test
1501 */
1502 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5400, TestSize.Level2)
1503 {
1504 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1505 ASSERT_NE(nullptr, capability);
1506 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1507 }
1508 /**
1509 * @tc.number : VIDEO_HWDEC_CAP_API_5410
1510 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1511 * @tc.desc : api test
1512 */
1513 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5410, TestSize.Level2)
1514 {
1515 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1516 ASSERT_NE(nullptr, capability);
1517 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1518 }
1519
1520 /**
1521 * @tc.number : VIDEO_HWDEC_CAP_API_5500
1522 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1523 * @tc.desc : api test
1524 */
1525 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5500, TestSize.Level2)
1526 {
1527 OH_AVErrCode ret = AV_ERR_OK;
1528 OH_AVRange range;
1529 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1530 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1531 }
1532
1533 /**
1534 * @tc.number : VIDEO_HWDEC_CAP_API_5600
1535 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1536 * @tc.desc : api test
1537 */
1538 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5600, TestSize.Level2)
1539 {
1540 OH_AVErrCode ret = AV_ERR_OK;
1541 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1542 ASSERT_NE(nullptr, capability);
1543 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1544 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1545 }
1546
1547 /**
1548 * @tc.number : VIDEO_HWDEC_CAP_API_5700
1549 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1550 * @tc.desc : api test
1551 */
1552 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5700, TestSize.Level2)
1553 {
1554 OH_AVErrCode ret = AV_ERR_OK;
1555 OH_AVRange range;
1556 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1557 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1558 ASSERT_NE(nullptr, capability);
1559 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1560 ASSERT_EQ(AV_ERR_OK, ret);
1561 ASSERT_GE(range.minVal, 0);
1562 ASSERT_GT(range.maxVal, 0);
1563 }
1564
1565 /**
1566 * @tc.number : VIDEO_HWDEC_CAP_API_1600
1567 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1568 * @tc.desc : api test
1569 */
1570 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1600, TestSize.Level2)
1571 {
1572 OH_AVErrCode ret = AV_ERR_OK;
1573 OH_AVRange range;
1574 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1575 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1576 ASSERT_NE(nullptr, capability);
1577 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1578 ASSERT_EQ(AV_ERR_OK, ret);
1579 ASSERT_GE(range.minVal, 0);
1580 ASSERT_GT(range.maxVal, 0);
1581 }
1582
1583 /**
1584 * @tc.number : VIDEO_HWDEC_CAP_API_5800
1585 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1586 * @tc.desc : api test
1587 */
1588 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5800, TestSize.Level2)
1589 {
1590 OH_AVErrCode ret = AV_ERR_OK;
1591 OH_AVRange range;
1592 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1593 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1594 }
1595
1596 /**
1597 * @tc.number : VIDEO_HWDEC_CAP_API_5900
1598 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1599 * @tc.desc : api test
1600 */
1601 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5900, TestSize.Level2)
1602 {
1603 OH_AVErrCode ret = AV_ERR_OK;
1604 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1605 ASSERT_NE(nullptr, capability);
1606 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1607 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1608 }
1609
1610 /**
1611 * @tc.number : VIDEO_HWDEC_CAP_API_6000
1612 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1613 * @tc.desc : api test
1614 */
1615 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6000, TestSize.Level2)
1616 {
1617 OH_AVErrCode ret = AV_ERR_OK;
1618 OH_AVRange range;
1619 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1620 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1621 ASSERT_NE(nullptr, capability);
1622 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1623 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1624 }
1625
1626 /**
1627 * @tc.number : VIDEO_HWDEC_CAP_API_6100
1628 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1629 * @tc.desc : api test
1630 */
1631 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6100, TestSize.Level2)
1632 {
1633 OH_AVErrCode ret = AV_ERR_OK;
1634 OH_AVRange range;
1635 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1636 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1637 ASSERT_NE(nullptr, capability);
1638 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1639 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1640 }
1641
1642 /**
1643 * @tc.number : VIDEO_HWDEC_CAP_API_6200
1644 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1645 * @tc.desc : api test
1646 */
1647 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6200, TestSize.Level2)
1648 {
1649 OH_AVErrCode ret = AV_ERR_OK;
1650 OH_AVRange range;
1651 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1652 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1653 ASSERT_NE(nullptr, capability);
1654 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1655 ASSERT_EQ(AV_ERR_OK, ret);
1656 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1657 ASSERT_GE(range.minVal, 0);
1658 ASSERT_GT(range.maxVal, 0);
1659
1660 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1661 ASSERT_EQ(AV_ERR_OK, ret);
1662 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1663 ASSERT_GE(range.minVal, 0);
1664 ASSERT_GT(range.maxVal, 0);
1665 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 3840, 2160, &range);
1666 ASSERT_EQ(AV_ERR_OK, ret);
1667 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1668 ASSERT_GE(range.minVal, 0);
1669 ASSERT_GT(range.maxVal, 0);
1670 }
1671
1672 /**
1673 * @tc.number : VIDEO_HWDEC_CAP_API_6210
1674 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1675 * @tc.desc : api test
1676 */
1677 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6210, TestSize.Level2)
1678 {
1679 OH_AVErrCode ret = AV_ERR_OK;
1680 OH_AVRange range;
1681 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1682 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1683 ASSERT_NE(nullptr, capability);
1684 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1685 ASSERT_EQ(AV_ERR_OK, ret);
1686 }
1687
1688 /**
1689 * @tc.number : VIDEO_HWDEC_CAP_API_6300
1690 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1691 * @tc.desc : api test
1692 */
1693 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6300, TestSize.Level2)
1694 {
1695 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1696 ASSERT_NE(nullptr, capability);
1697 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1698 }
1699
1700 /**
1701 * @tc.number : VIDEO_HWDEC_CAP_API_6400
1702 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1703 * @tc.desc : api test
1704 */
1705 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6400, TestSize.Level2)
1706 {
1707 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1708 ASSERT_NE(nullptr, capability);
1709 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1710 }
1711
1712 /**
1713 * @tc.number : VIDEO_HWDEC_CAP_API_6500
1714 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1715 * @tc.desc : api test
1716 */
1717 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6500, TestSize.Level2)
1718 {
1719 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1720 ASSERT_NE(nullptr, capability);
1721 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1722 }
1723
1724 /**
1725 * @tc.number : VIDEO_HWDEC_CAP_API_6600
1726 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1727 * @tc.desc : api test
1728 */
1729 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6600, TestSize.Level2)
1730 {
1731 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1732 }
1733
1734 /**
1735 * @tc.number : VIDEO_HWDEC_CAP_API_6700
1736 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1737 * @tc.desc : api test
1738 */
1739 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6700, TestSize.Level2)
1740 {
1741 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1742 ASSERT_NE(nullptr, capability);
1743 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1744 }
1745
1746 /**
1747 * @tc.number : VIDEO_HWDEC_CAP_API_6710
1748 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1749 * @tc.desc : api test
1750 */
1751 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6710, TestSize.Level2)
1752 {
1753 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1754 ASSERT_NE(nullptr, capability);
1755 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1756 }
1757
1758 /**
1759 * @tc.number : VIDEO_HWDEC_CAP_API_6800
1760 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1761 * @tc.desc : api test
1762 */
1763 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6800, TestSize.Level2)
1764 {
1765 OH_AVErrCode ret = AV_ERR_OK;
1766 const int32_t *pixelFormat = nullptr;
1767 uint32_t pixelFormatNum = 0;
1768 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1769 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1770 }
1771
1772 /**
1773 * @tc.number : VIDEO_HWDEC_CAP_API_6900
1774 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1775 * @tc.desc : api test
1776 */
1777 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6900, TestSize.Level2)
1778 {
1779 OH_AVErrCode ret = AV_ERR_OK;
1780 uint32_t pixelFormatNum = 0;
1781 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1782 ASSERT_NE(nullptr, capability);
1783 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1784 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1785 }
1786
1787 /**
1788 * @tc.number : VIDEO_HWDEC_CAP_API_7000
1789 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1790 * @tc.desc : api test
1791 */
1792 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7000, TestSize.Level2)
1793 {
1794 OH_AVErrCode ret = AV_ERR_OK;
1795 const int32_t *pixelFormat = nullptr;
1796 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1797 ASSERT_NE(nullptr, capability);
1798 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1799 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1800 }
1801
1802 /**
1803 * @tc.number : VIDEO_HWDEC_CAP_API_7100
1804 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1805 * @tc.desc : api test
1806 */
1807 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7100, TestSize.Level2)
1808 {
1809 OH_AVErrCode ret = AV_ERR_OK;
1810 const int32_t *pixelFormat = nullptr;
1811 uint32_t pixelFormatNum = 0;
1812 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1813 ASSERT_NE(nullptr, capability);
1814 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1815 ASSERT_NE(nullptr, pixelFormat);
1816 ASSERT_GT(pixelFormatNum, 0);
1817 ASSERT_EQ(AV_ERR_OK, ret);
1818 for (int i = 0; i < pixelFormatNum; i++) {
1819 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1820 ASSERT_NE(nullptr, vdec_);
1821 format = OH_AVFormat_Create();
1822 ASSERT_NE(nullptr, format);
1823 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1824 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1825 EXPECT_GE(pixelFormat[i], 0);
1826 cout<<"-----------"<< pixelFormat[i] << endl;
1827 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1828 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1829 OH_AVFormat_Destroy(format);
1830 OH_VideoDecoder_Destroy(vdec_);
1831 }
1832 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1833 ASSERT_NE(nullptr, vdec_);
1834 format = OH_AVFormat_Create();
1835 ASSERT_NE(nullptr, format);
1836 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1837 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1838 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1839 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1840 OH_VideoDecoder_Destroy(vdec_);
1841 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1842 ASSERT_NE(nullptr, vdec_);
1843 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
1844 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1845 OH_VideoDecoder_Destroy(vdec_);
1846 if (!access("/system/lib64/media/", 0)) {
1847 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1848 ASSERT_NE(nullptr, vdec_);
1849 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
1850 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1851 } else {
1852 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1853 ASSERT_NE(nullptr, vdec_);
1854 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
1855 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1856 }
1857 }
1858
1859 /**
1860 * @tc.number : VIDEO_HWDEC_CAP_API_1200
1861 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1862 * @tc.desc : api test
1863 */
1864 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1200, TestSize.Level2)
1865 {
1866 OH_AVErrCode ret = AV_ERR_OK;
1867 const int32_t *pixelFormat = nullptr;
1868 uint32_t pixelFormatNum = 0;
1869 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1870 ASSERT_NE(nullptr, capability);
1871 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1872 ASSERT_NE(nullptr, pixelFormat);
1873 ASSERT_GT(pixelFormatNum, 0);
1874 ASSERT_EQ(AV_ERR_OK, ret);
1875 for (int i = 0; i < pixelFormatNum; i++) {
1876 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1877 ASSERT_NE(nullptr, vdec_);
1878 format = OH_AVFormat_Create();
1879 ASSERT_NE(nullptr, format);
1880 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1881 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1882 EXPECT_GE(pixelFormat[i], 0);
1883 cout<<"-----------"<< pixelFormat[i] << endl;
1884 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1885 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1886 OH_AVFormat_Destroy(format);
1887 OH_VideoDecoder_Destroy(vdec_);
1888 }
1889 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1890 ASSERT_NE(nullptr, vdec_);
1891 format = OH_AVFormat_Create();
1892 ASSERT_NE(nullptr, format);
1893 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1894 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1895 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1896 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1897 OH_VideoDecoder_Destroy(vdec_);
1898 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1899 ASSERT_NE(nullptr, vdec_);
1900 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
1901 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1902 OH_VideoDecoder_Destroy(vdec_);
1903 if (!access("/system/lib64/media/", 0)) {
1904 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1905 ASSERT_NE(nullptr, vdec_);
1906 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
1907 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1908 } else {
1909 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
1910 ASSERT_NE(nullptr, vdec_);
1911 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
1912 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1913 }
1914 }
1915
1916 /**
1917 * @tc.number : VIDEO_HWDEC_CAP_API_7200
1918 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1919 * @tc.desc : api test
1920 */
1921 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7200, TestSize.Level2)
1922 {
1923 OH_AVErrCode ret = AV_ERR_OK;
1924 const int32_t *profiles = nullptr;
1925 uint32_t profileNum = 0;
1926 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
1927 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1928 }
1929
1930 /**
1931 * @tc.number : VIDEO_HWDEC_CAP_API_7300
1932 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1933 * @tc.desc : api test
1934 */
1935 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7300, TestSize.Level2)
1936 {
1937 OH_AVErrCode ret = AV_ERR_OK;
1938 uint32_t profileNum = 0;
1939 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1940 ASSERT_NE(nullptr, capability);
1941 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
1942 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1943 }
1944
1945 /**
1946 * @tc.number : VIDEO_HWDEC_CAP_API_7400
1947 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1948 * @tc.desc : api test
1949 */
1950 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7400, TestSize.Level2)
1951 {
1952 OH_AVErrCode ret = AV_ERR_OK;
1953 const int32_t *profiles = nullptr;
1954 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1955 ASSERT_NE(nullptr, capability);
1956 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
1957 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1958 }
1959
1960 /**
1961 * @tc.number : VIDEO_HWDEC_CAP_API_7500
1962 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1963 * @tc.desc : api test
1964 */
1965 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7500, TestSize.Level2)
1966 {
1967 OH_AVErrCode ret = AV_ERR_OK;
1968 const int32_t *profiles = nullptr;
1969 uint32_t profileNum = 0;
1970 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
1971 ASSERT_NE(nullptr, capability);
1972 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1973 ASSERT_EQ(AV_ERR_OK, ret);
1974 ASSERT_GT(profileNum, 0);
1975 ASSERT_NE(nullptr, profiles);
1976 for (int i = 0; i < profileNum; i++) {
1977 EXPECT_GE(profiles[i], 0);
1978 }
1979 }
1980
1981 /**
1982 * @tc.number : VIDEO_HWDEC_CAP_API_1300
1983 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1984 * @tc.desc : api test
1985 */
1986 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1300, TestSize.Level2)
1987 {
1988 OH_AVErrCode ret = AV_ERR_OK;
1989 const int32_t *profiles = nullptr;
1990 uint32_t profileNum = 0;
1991 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
1992 ASSERT_NE(nullptr, capability);
1993 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1994 ASSERT_EQ(AV_ERR_OK, ret);
1995 ASSERT_GT(profileNum, 0);
1996 ASSERT_NE(nullptr, profiles);
1997 for (int i = 0; i < profileNum; i++) {
1998 EXPECT_GE(profiles[i], 0);
1999 }
2000 }
2001
2002 /**
2003 * @tc.number : VIDEO_HWDEC_CAP_API_7600
2004 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2005 * @tc.desc : api test
2006 */
2007 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7600, TestSize.Level2)
2008 {
2009 OH_AVErrCode ret = AV_ERR_OK;
2010 const int32_t *levels = nullptr;
2011 uint32_t levelNum = 0;
2012 ret = OH_AVCapability_GetSupportedLevelsForProfile(nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
2013 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2014 }
2015
2016 /**
2017 * @tc.number : VIDEO_HWDEC_CAP_API_7700
2018 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2019 * @tc.desc : api test
2020 */
2021 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7700, TestSize.Level2)
2022 {
2023 OH_AVErrCode ret = AV_ERR_OK;
2024 const int32_t *levels = nullptr;
2025 uint32_t levelNum = 0;
2026 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
2027 ASSERT_NE(nullptr, capability);
2028 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
2029 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2030 }
2031
2032 /**
2033 * @tc.number : VIDEO_HWDEC_CAP_API_7800
2034 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2035 * @tc.desc : api test
2036 */
2037 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7800, TestSize.Level2)
2038 {
2039 OH_AVErrCode ret = AV_ERR_OK;
2040 uint32_t levelNum = 0;
2041 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
2042 ASSERT_NE(nullptr, capability);
2043 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
2044 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2045 }
2046
2047 /**
2048 * @tc.number : VIDEO_HWDEC_CAP_API_7900
2049 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2050 * @tc.desc : api test
2051 */
2052 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7900, TestSize.Level2)
2053 {
2054 OH_AVErrCode ret = AV_ERR_OK;
2055 const int32_t *levels = nullptr;
2056 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
2057 ASSERT_NE(nullptr, capability);
2058 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, nullptr);
2059 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2060 }
2061
2062 /**
2063 * @tc.number : VIDEO_HWDEC_CAP_API_8000
2064 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2065 * @tc.desc : api test
2066 */
2067 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8000, TestSize.Level2)
2068 {
2069 OH_AVErrCode ret = AV_ERR_OK;
2070 const int32_t *levels = nullptr;
2071 uint32_t levelNum = 0;
2072 const int32_t *profiles = nullptr;
2073 uint32_t profileNum = 0;
2074 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
2075 ASSERT_NE(nullptr, capability);
2076 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2077 ASSERT_EQ(AV_ERR_OK, ret);
2078 ASSERT_GT(profileNum, 0);
2079 ASSERT_NE(nullptr, profiles);
2080 for (int i = 0; i < profileNum; i++) {
2081 EXPECT_GE(profiles[i], 0);
2082 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
2083 ASSERT_EQ(AV_ERR_OK, ret);
2084 ASSERT_NE(nullptr, levels);
2085 EXPECT_GT(levelNum, 0);
2086 for (int j = 0; j < levelNum; j++) {
2087 EXPECT_GE(levels[j], 0);
2088 }
2089 }
2090 }
2091
2092 /**
2093 * @tc.number : VIDEO_HWDEC_CAP_API_1400
2094 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2095 * @tc.desc : api test
2096 */
2097 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1400, TestSize.Level2)
2098 {
2099 OH_AVErrCode ret = AV_ERR_OK;
2100 const int32_t *levels = nullptr;
2101 uint32_t levelNum = 0;
2102 uint32_t profileNum = 0;
2103 const int32_t *profiles = nullptr;
2104 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
2105 ASSERT_NE(nullptr, capability);
2106 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2107 ASSERT_EQ(AV_ERR_OK, ret);
2108 ASSERT_GT(profileNum, 0);
2109 ASSERT_NE(nullptr, profiles);
2110 for (int i = 0; i < profileNum; i++) {
2111 ASSERT_GE(profiles[i], 0);
2112 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
2113 ASSERT_EQ(AV_ERR_OK, ret);
2114 ASSERT_NE(nullptr, levels);
2115 ASSERT_GT(levelNum, 0);
2116 for (int j = 0; j < levelNum; j++) {
2117 EXPECT_GE(levels[j], 0);
2118 }
2119 }
2120 }
2121
2122 /**
2123 * @tc.number : VIDEO_HWDEC_CAP_API_8100
2124 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2125 * @tc.desc : api test
2126 */
2127 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8100, TestSize.Level2)
2128 {
2129 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(nullptr, AVC_PROFILE_BASELINE, 1));
2130 }
2131
2132 /**
2133 * @tc.number : VIDEO_HWDEC_CAP_API_8200
2134 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2135 * @tc.desc : api test
2136 */
2137 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8200, TestSize.Level2)
2138 {
2139 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
2140 ASSERT_NE(nullptr, capability);
2141 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
2142 }
2143
2144 /**
2145 * @tc.number : VIDEO_HWDEC_CAP_API_8300
2146 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2147 * @tc.desc : api test
2148 */
2149 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8300, TestSize.Level2)
2150 {
2151 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
2152 ASSERT_NE(nullptr, capability);
2153 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
2154 }
2155
2156 /**
2157 * @tc.number : VIDEO_HWDEC_CAP_API_8310
2158 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2159 * @tc.desc : api test
2160 */
2161 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8310, TestSize.Level2)
2162 {
2163 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
2164 ASSERT_NE(nullptr, capability);
2165 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, HEVC_PROFILE_MAIN, 1));
2166 }
2167
2168 /**
2169 * @tc.number : VIDEO_HWDEC_ATTIME_API_0010
2170 * @tc.name : OH_VideoDecoder_RenderOutputBufferAtTime use renderTimestampNs of < 0
2171 * @tc.desc : api test
2172 */
2173 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ATTIME_API_0010, TestSize.Level1)
2174 {
2175 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
2176 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
2177 vDecSample->INP_DIR = INP_DIR_720_30;
2178 vDecSample->SF_OUTPUT = true;
2179 vDecSample->DEFAULT_WIDTH = 1280;
2180 vDecSample->DEFAULT_HEIGHT = 720;
2181 vDecSample->DEFAULT_FRAME_RATE = 30;
2182 vDecSample->rsAtTime = true;
2183 vDecSample->isAPI = true;
2184 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
2185 vDecSample->WaitForEOS();
2186 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->errCount);
2187 }
2188 } // namespace