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