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