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
19 #include <atomic>
20 #include <fstream>
21 #include <thread>
22 #include <mutex>
23 #include <queue>
24 #include <string>
25
26 #include "gtest/gtest.h"
27 #include "videodec_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 #ifdef SUPPORT_DRM
35 #include "native_mediakeysession.h"
36 #include "native_mediakeysystem.h"
37 #endif
38
39 #define PIXFORMAT_NUM 4
40
41 using namespace std;
42 using namespace OHOS;
43 using namespace OHOS::Media;
44 using namespace testing::ext;
45 namespace OHOS {
46 namespace Media {
47 class SwdecApiNdkTest : public testing::Test {
48 public:
49 // SetUpTestCase: Called before all test cases
50 static void SetUpTestCase(void);
51 // TearDownTestCase: Called after all test case
52 static void TearDownTestCase(void);
53 // SetUp: Called before each test cases
54 void SetUp(void);
55 // TearDown: Called after each test cases
56 void TearDown(void);
57 };
58
59 OH_AVCodec *vdec_ = NULL;
60 OH_AVCapability *cap = nullptr;
61 const string INVALID_CODEC_NAME = "avdec_h264";
62 const string CODEC_NAME = "OH.Media.Codec.Decoder.Video.AVC";
63 VDecSignal *signal_;
64 constexpr uint32_t DEFAULT_WIDTH = 1920;
65 constexpr uint32_t DEFAULT_HEIGHT = 1080;
66 constexpr uint32_t DEFAULT_FRAME_RATE = 30;
67 OH_AVFormat *format;
SetUpTestCase()68 void SwdecApiNdkTest::SetUpTestCase() {}
TearDownTestCase()69 void SwdecApiNdkTest::TearDownTestCase() {}
SetUp()70 void SwdecApiNdkTest::SetUp()
71 {
72 signal_ = new VDecSignal();
73 }
TearDown()74 void SwdecApiNdkTest::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 {
93 /**
94 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0100
95 * @tc.name : OH_VideoDecoder_FindDecoder para error
96 * @tc.desc : function test
97 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0100, TestSize.Level2)98 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0100, TestSize.Level2)
99 {
100 vdec_ = OH_VideoDecoder_CreateByMime(NULL);
101 ASSERT_EQ(NULL, vdec_);
102 }
103
104 /**
105 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0200
106 * @tc.name : OH_VideoDecoder_CreateByName para error
107 * @tc.desc : function test
108 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0200, TestSize.Level2)109 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0200, TestSize.Level2)
110 {
111 vdec_ = OH_VideoDecoder_CreateByName(NULL);
112 ASSERT_EQ(NULL, vdec_);
113 }
114
115 /**
116 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3300
117 * @tc.name : OH_VideoDecoder_SetCallback para error
118 * @tc.desc : function test
119 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3300, TestSize.Level2)120 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3300, TestSize.Level2)
121 {
122 OH_AVCodecAsyncCallback cb_;
123 cb_.onError = VdecError;
124 cb_.onStreamChanged = VdecFormatChanged;
125 cb_.onNeedInputData = VdecInputDataReady;
126 cb_.onNeedOutputData = VdecOutputDataReady;
127
128 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
129 }
130
131 /**
132 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1800
133 * @tc.name : OH_VideoDecoder_SetCallback para error
134 * @tc.desc : function test
135 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1800, TestSize.Level2)136 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1800, TestSize.Level2)
137 {
138 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
139 ASSERT_NE(NULL, vdec_);
140
141 OH_AVCodecAsyncCallback cb2_;
142 cb2_.onError = NULL;
143 cb2_.onStreamChanged = NULL;
144 cb2_.onNeedInputData = NULL;
145 cb2_.onNeedOutputData = NULL;
146 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb2_, static_cast<void *>(signal_)));
147 }
148
149 /**
150 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0300
151 * @tc.name : OH_VideoDecoder_SetCallback para error
152 * @tc.desc : function test
153 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0300, TestSize.Level2)154 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0300, TestSize.Level2)
155 {
156 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
157 OH_AVCodecAsyncCallback cb_;
158 cb_.onError = VdecError;
159 cb_.onStreamChanged = VdecFormatChanged;
160 cb_.onNeedInputData = VdecInputDataReady;
161 cb_.onNeedOutputData = VdecOutputDataReady;
162 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
163 }
164
165 /**
166 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0400
167 * @tc.name : OH_VideoDecoder_Destroy para error
168 * @tc.desc : function test
169 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0400, TestSize.Level2)170 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0400, TestSize.Level2)
171 {
172 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(NULL));
173 }
174
175 /**
176 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0500
177 * @tc.name : OH_VideoDecoder_Configure para error
178 * @tc.desc : function test
179 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0500, TestSize.Level2)180 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0500, TestSize.Level2)
181 {
182 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
183 ASSERT_NE(NULL, vdec_);
184 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, NULL));
185 }
186
187 /**
188 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1400
189 * @tc.name : OH_VideoDecoder_Configure para error
190 * @tc.desc : function test
191 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1400, TestSize.Level2)192 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1400, TestSize.Level2)
193 {
194 OH_AVFormat *format = OH_AVFormat_Create();
195 ASSERT_NE(NULL, format);
196 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
197 }
198
199 /**
200 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1400
201 * @tc.name : OH_VideoDecoder_Configure para error
202 * @tc.desc : function test
203 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5000, TestSize.Level2)204 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5000, TestSize.Level2)
205 {
206 OH_AVFormat *format = OH_AVFormat_Create();
207 ASSERT_NE(NULL, format);
208
209 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
210 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
211 }
212
213 /**
214 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1400
215 * @tc.name : OH_VideoDecoder_Configure para error
216 * @tc.desc : function test
217 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5100, TestSize.Level2)218 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5100, TestSize.Level2)
219 {
220 OH_AVFormat *format = OH_AVFormat_Create();
221 ASSERT_NE(NULL, format);
222
223 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
224 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
225 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
226 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
227 }
228
229 /**
230 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0600
231 * @tc.name : OH_VideoDecoder_Start para error
232 * @tc.desc : function test
233 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0600, TestSize.Level2)234 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0600, TestSize.Level2)
235 {
236 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Start(NULL));
237 }
238
239 /**
240 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0700
241 * @tc.name : OH_VideoDecoder_Stop para error
242 * @tc.desc : function test
243 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0700, TestSize.Level2)244 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0700, TestSize.Level2)
245 {
246 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Stop(NULL));
247 }
248
249 /**
250 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0800
251 * @tc.name : OH_VideoDecoder_Flush para error
252 * @tc.desc : function test
253 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0800, TestSize.Level2)254 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0800, TestSize.Level2)
255 {
256 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Flush(NULL));
257 }
258
259 /**
260 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0900
261 * @tc.name : OH_VideoDecoder_Reset para error
262 * @tc.desc : function test
263 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0900, TestSize.Level2)264 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0900, TestSize.Level2)
265 {
266 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Reset(NULL));
267 }
268
269 /**
270 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1000
271 * @tc.name : OH_VideoDecoder_GetOutputDescription para error
272 * @tc.desc : function test
273 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1000, TestSize.Level2)274 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1000, TestSize.Level2)
275 {
276 ASSERT_EQ(NULL, OH_VideoDecoder_GetOutputDescription(NULL));
277 }
278
279 /**
280 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1100
281 * @tc.name : OH_VideoDecoder_SetParameter para error
282 * @tc.desc : function test
283 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1100, TestSize.Level2)284 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1100, TestSize.Level2)
285 {
286 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
287 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(vdec_, NULL));
288 }
289
290 /**
291 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_4100
292 * @tc.name : OH_VideoDecoder_Prepare para error
293 * @tc.desc : function test
294 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_4100, TestSize.Level2)295 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_4100, TestSize.Level2)
296 {
297 OH_AVErrCode ret = AV_ERR_OK;
298 ret = OH_VideoDecoder_Prepare(nullptr);
299 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
300 }
301
302 /**
303 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1500
304 * @tc.name : OH_VideoDecoder_SetParameter para error
305 * @tc.desc : function test
306 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1500, TestSize.Level2)307 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1500, TestSize.Level2)
308 {
309 OH_AVFormat *format = OH_AVFormat_Create();
310 ASSERT_NE(NULL, format);
311
312 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
313 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
314 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
315 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(NULL, format));
316 }
317
318 /**
319 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1200
320 * @tc.name : OH_VideoDecoder_SetSurface para error
321 * @tc.desc : function test
322 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1200, TestSize.Level2)323 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1200, TestSize.Level2)
324 {
325 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
326 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetSurface(vdec_, NULL));
327 }
328
329 /**
330 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1600
331 * @tc.name : OH_VideoDecoder_CreateByName para error
332 * @tc.desc : function test
333 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1600, TestSize.Level2)334 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1600, TestSize.Level2)
335 {
336 vdec_ = OH_VideoDecoder_CreateByName(INVALID_CODEC_NAME.c_str());
337 ASSERT_EQ(NULL, vdec_);
338 }
339
340 /**
341 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1700
342 * @tc.name : OH_VideoDecoder_CreateByName para error
343 * @tc.desc : function test
344 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1700, TestSize.Level2)345 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1700, TestSize.Level2)
346 {
347 vdec_ = OH_VideoDecoder_CreateByMime(INVALID_CODEC_NAME.c_str());
348 ASSERT_EQ(NULL, vdec_);
349 }
350
351 /**
352 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1700
353 * @tc.name : OH_VideoDecoder_IsValid para error
354 * @tc.desc : function test
355 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2200, TestSize.Level2)356 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2200, TestSize.Level2)
357 {
358 bool isValid = false;
359 OH_AVErrCode ret = AV_ERR_OK;
360 ret = OH_VideoDecoder_IsValid(nullptr, &isValid);
361 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
362 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
363 ASSERT_NE(NULL, vdec_);
364 ret = OH_VideoDecoder_IsValid(vdec_, nullptr);
365 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
366 }
367
368 /**
369 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2500
370 * @tc.name : OH_VideoDecoder_RenderOutputData para error
371 * @tc.desc : function test
372 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2500, TestSize.Level2)373 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2500, TestSize.Level2)
374 {
375 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_RenderOutputData(NULL, 0));
376 }
377
378 /**
379 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2600
380 * @tc.name : OH_VideoDecoder_RenderOutputData para error
381 * @tc.desc : function test
382 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2600, TestSize.Level2)383 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2600, TestSize.Level2)
384 {
385 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
386 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_RenderOutputData(vdec_, 0));
387 }
388
389 /**
390 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2700
391 * @tc.name : OH_VideoDecoder_FreeOutputData para error
392 * @tc.desc : function test
393 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2700, TestSize.Level2)394 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2700, TestSize.Level2)
395 {
396 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_FreeOutputData(NULL, 0));
397 }
398
399 /**
400 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2800
401 * @tc.name : OH_VideoDecoder_FreeOutputData para error
402 * @tc.desc : function test
403 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2800, TestSize.Level2)404 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2800, TestSize.Level2)
405 {
406 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
407 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, 0));
408 }
409
410 /**
411 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2900
412 * @tc.name : OH_VideoDecoder_FreeOutputData para error
413 * @tc.desc : function test
414 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2900, TestSize.Level2)415 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2900, TestSize.Level2)
416 {
417 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
418 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, -1));
419 }
420
421 /**
422 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3000
423 * @tc.name : OH_VideoDecoder_PushInputData para error
424 * @tc.desc : function test
425 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3000, TestSize.Level2)426 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3000, TestSize.Level2)
427 {
428 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
429
430 OH_AVCodecBufferAttr attr;
431 attr.pts = -1;
432 attr.size = -1;
433 attr.offset = -1;
434 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
435
436 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
437 }
438
439 /**
440 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3100
441 * @tc.name : OH_VideoDecoder_PushInputData para error
442 * @tc.desc : function test
443 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3100, TestSize.Level2)444 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3100, TestSize.Level2)
445 {
446 OH_AVCodecBufferAttr attr;
447 attr.pts = 0;
448 attr.size = 0;
449 attr.offset = 0;
450 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
451
452 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, -1, attr));
453 }
454
455 /**
456 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3200
457 * @tc.name : OH_VideoDecoder_PushInputData para error
458 * @tc.desc : function test
459 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3200, TestSize.Level2)460 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3200, TestSize.Level2)
461 {
462 OH_AVCodecBufferAttr attr;
463 attr.pts = 0;
464 attr.size = 0;
465 attr.offset = 0;
466 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
467
468 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, 0, attr));
469 }
470
471 /**
472 * @tc.number : VIDEO_SWDEC_API_0100
473 * @tc.name : repeat create OH_VideoDecoder_CreateByName
474 * @tc.desc : function test
475 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0100, TestSize.Level2)476 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0100, TestSize.Level2)
477 {
478 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
479 ASSERT_NE(vdec_, NULL);
480 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
481 ASSERT_NE(vdec_2, NULL);
482 OH_VideoDecoder_Destroy(vdec_2);
483 vdec_2 = nullptr;
484 }
485
486 /**
487 * @tc.number : VIDEO_SWDEC_API_0200
488 * @tc.name : create configure configure
489 * @tc.desc : function test
490 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0200, TestSize.Level2)491 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0200, TestSize.Level2)
492 {
493 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
494 ASSERT_NE(NULL, vdec_);
495
496 OH_AVFormat *format = OH_AVFormat_Create();
497 ASSERT_NE(NULL, format);
498
499 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
500 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
501 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
502
503 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
504 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Configure(vdec_, format));
505 }
506
507 /**
508 * @tc.number : VIDEO_SWDEC_API_0300
509 * @tc.name : create configure start start
510 * @tc.desc : function test
511 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0300, TestSize.Level2)512 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0300, TestSize.Level2)
513 {
514 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
515 ASSERT_NE(NULL, vdec_);
516
517 OH_AVFormat *format = OH_AVFormat_Create();
518 ASSERT_NE(NULL, format);
519
520 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
521 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
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_OK, OH_VideoDecoder_Start(vdec_));
526 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Start(vdec_));
527 }
528
529 /**
530 * @tc.number : VIDEO_SWDEC_API_0400
531 * @tc.name : create configure start stop stop
532 * @tc.desc : function test
533 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0400, TestSize.Level2)534 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0400, TestSize.Level2)
535 {
536 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
537 ASSERT_NE(NULL, vdec_);
538
539 OH_AVFormat *format = OH_AVFormat_Create();
540 ASSERT_NE(NULL, format);
541
542 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
543 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
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_OK, OH_VideoDecoder_Stop(vdec_));
549 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Stop(vdec_));
550 }
551
552 /**
553 * @tc.number : VIDEO_SWDEC_API_0500
554 * @tc.name : create configure start stop reset reset
555 * @tc.desc : function test
556 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0500, TestSize.Level2)557 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0500, TestSize.Level2)
558 {
559 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
560 ASSERT_NE(NULL, vdec_);
561
562 OH_AVFormat *format = OH_AVFormat_Create();
563 ASSERT_NE(NULL, format);
564
565 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
566 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
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_OK, OH_VideoDecoder_Reset(vdec_));
573 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
574 }
575
576 /**
577 * @tc.number : VIDEO_SWDEC_API_0600
578 * @tc.name : create configure start EOS EOS
579 * @tc.desc : function test
580 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0600, TestSize.Level2)581 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0600, TestSize.Level2)
582 {
583 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
584 ASSERT_NE(NULL, vdec_);
585
586 OH_AVFormat *format = OH_AVFormat_Create();
587 ASSERT_NE(NULL, format);
588
589 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
590 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
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
596 OH_AVCodecBufferAttr attr;
597 attr.pts = 0;
598 attr.size = 0;
599 attr.offset = 0;
600 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
601
602 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
603 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
604 }
605
606 /**
607 * @tc.number : VIDEO_SWDEC_API_0700
608 * @tc.name : create configure start flush flush
609 * @tc.desc : function test
610 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0700, TestSize.Level2)611 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0700, TestSize.Level2)
612 {
613 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
614 ASSERT_NE(NULL, vdec_);
615
616 OH_AVFormat *format = OH_AVFormat_Create();
617 ASSERT_NE(NULL, format);
618
619 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
620 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
621 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
622
623 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
624 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
625 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
626 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Flush(vdec_));
627 }
628
629 /**
630 * @tc.number : VIDEO_SWDEC_API_0800
631 * @tc.name : create configure start stop release release
632 * @tc.desc : function test
633 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0800, TestSize.Level2)634 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0800, TestSize.Level2)
635 {
636 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
637 ASSERT_NE(NULL, vdec_);
638
639 OH_AVFormat *format = OH_AVFormat_Create();
640 ASSERT_NE(NULL, format);
641
642 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
643 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
644 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
645
646 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
647 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
648 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
649 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
650 vdec_ = nullptr;
651 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
652 }
653
654 /**
655 * @tc.number : VIDEO_SWDEC_API_0900
656 * @tc.name : create create
657 * @tc.desc : function test
658 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0900, TestSize.Level2)659 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0900, TestSize.Level2)
660 {
661 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
662 ASSERT_NE(vdec_, NULL);
663 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
664 ASSERT_NE(vdec_2, NULL);
665 OH_VideoDecoder_Destroy(vdec_2);
666 vdec_2 = nullptr;
667 }
668
669 /**
670 * @tc.number : VIDEO_SWDEC_API_1000
671 * @tc.name : repeat OH_VideoDecoder_SetCallback
672 * @tc.desc : function test
673 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1000, TestSize.Level2)674 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1000, TestSize.Level2)
675 {
676 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
677 OH_AVCodecAsyncCallback cb_;
678 cb_.onError = VdecError;
679 cb_.onStreamChanged = VdecFormatChanged;
680 cb_.onNeedInputData = VdecInputDataReady;
681 cb_.onNeedOutputData = VdecOutputDataReady;
682 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
683 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
684 }
685
686 /**
687 * @tc.number : VIDEO_SWDEC_API_1100
688 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
689 * @tc.desc : function test
690 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1100, TestSize.Level2)691 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1100, TestSize.Level2)
692 {
693 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
694 OH_AVFormat *format = OH_VideoDecoder_GetOutputDescription(vdec_);
695 ASSERT_NE(NULL, format);
696 format = OH_VideoDecoder_GetOutputDescription(vdec_);
697 ASSERT_NE(NULL, format);
698 }
699
700 /**
701 * @tc.number : VIDEO_SWDEC_API_1200
702 * @tc.name : repeat OH_VideoDecoder_SetParameter
703 * @tc.desc : function test
704 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1200, TestSize.Level2)705 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1200, TestSize.Level2)
706 {
707 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
708 ASSERT_NE(NULL, vdec_);
709
710 OH_AVFormat *format = OH_AVFormat_Create();
711 ASSERT_NE(NULL, format);
712
713 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
714 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
715 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
716
717 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
718 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
719 }
720
721 /**
722 * @tc.number : VIDEO_SWDEC_CAP_API_0100
723 * @tc.name : OH_AVCodec_GetCapability
724 * @tc.desc : function test
725 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0100, TestSize.Level2)726 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0100, TestSize.Level2)
727 {
728 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false);
729 ASSERT_NE(cap, nullptr);
730 }
731
732 /**
733 * @tc.number : VIDEO_SWDEC_CAP_API_0300
734 * @tc.name : OH_AVCodec_GetCapability
735 * @tc.desc : function test
736 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0300, TestSize.Level2)737 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0300, TestSize.Level2)
738 {
739 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
740 ASSERT_NE(cap, nullptr);
741 }
742
743 /**
744 * @tc.number : VIDEO_SWDEC_CAP_API_0400
745 * @tc.name : OH_AVCodec_GetCapability
746 * @tc.desc : function test
747 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0400, TestSize.Level2)748 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0400, TestSize.Level2)
749 {
750 cap = OH_AVCodec_GetCapabilityByCategory(nullptr, false, SOFTWARE);
751 ASSERT_EQ(cap, nullptr);
752 }
753
754 /**
755 * @tc.number : VIDEO_SWDEC_CAP_API_0500
756 * @tc.name : OH_AVCodec_GetCapability
757 * @tc.desc : function test
758 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0500, TestSize.Level2)759 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0500, TestSize.Level2)
760 {
761 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
762 ASSERT_NE(cap, nullptr);
763 ASSERT_FALSE(OH_AVCapability_IsHardware(cap));
764 }
765
766 /**
767 * @tc.number : VIDEO_SWDEC_CAP_API_0600
768 * @tc.name : OH_AVCodec_GetCapability
769 * @tc.desc : function test
770 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0600, TestSize.Level2)771 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0600, TestSize.Level2)
772 {
773 ASSERT_FALSE(OH_AVCapability_IsHardware(nullptr));
774 }
775
776 /**
777 * @tc.number : VIDEO_SWDEC_CAP_API_0700
778 * @tc.name : OH_AVCodec_GetCapability
779 * @tc.desc : function test
780 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0700, TestSize.Level2)781 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0700, TestSize.Level2)
782 {
783 ASSERT_EQ(0, OH_AVCapability_GetMaxSupportedInstances(nullptr));
784 }
785
786 /**
787 * @tc.number : VIDEO_SWDEC_CAP_API_0800
788 * @tc.name : OH_AVCodec_GetCapability
789 * @tc.desc : function test
790 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0800, TestSize.Level2)791 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0800, TestSize.Level2)
792 {
793 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
794 ASSERT_NE(cap, nullptr);
795 ASSERT_EQ(64, OH_AVCapability_GetMaxSupportedInstances(cap));
796 }
797
798 /**
799 * @tc.number : VIDEO_SWDEC_CAP_API_0900
800 * @tc.name : OH_AVCodec_GetCapability
801 * @tc.desc : function test
802 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0900, TestSize.Level2)803 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0900, TestSize.Level2)
804 {
805 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
806 ASSERT_NE(cap, nullptr);
807 ASSERT_EQ(CODEC_NAME, OH_AVCapability_GetName(cap));
808 }
809
810 /**
811 * @tc.number : VIDEO_SWDEC_CAP_API_1000
812 * @tc.name : OH_AVCodec_GetCapability
813 * @tc.desc : function test
814 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1000, TestSize.Level2)815 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1000, TestSize.Level2)
816 {
817 const char *name = OH_AVCapability_GetName(nullptr);
818 int ret = strcmp("", name);
819 ASSERT_EQ(0, ret);
820 }
821
822 /**
823 * @tc.number : VIDEO_SWDEC_CAP_API_3100
824 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
825 * @tc.desc : api test
826 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3100, TestSize.Level2)827 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3100, TestSize.Level2)
828 {
829 OH_AVErrCode ret = AV_ERR_OK;
830 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
831 ASSERT_NE(nullptr, capability);
832 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
833 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
834 }
835
836 /**
837 * @tc.number : VIDEO_SWDEC_CAP_API_3200
838 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
839 * @tc.desc : api test
840 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3200, TestSize.Level2)841 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3200, TestSize.Level2)
842 {
843 OH_AVErrCode ret = AV_ERR_OK;
844 int32_t alignment = 0;
845 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
846 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
847 }
848
849 /**
850 * @tc.number : VIDEO_SWDEC_CAP_API_3300
851 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
852 * @tc.desc : api test
853 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3300, TestSize.Level2)854 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3300, TestSize.Level2)
855 {
856 OH_AVErrCode ret = AV_ERR_OK;
857 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
858 ASSERT_NE(nullptr, capability);
859 int32_t alignment = 0;
860 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
861 cout << "WidthAlignment " << alignment << endl;
862 ASSERT_EQ(AV_ERR_OK, ret);
863 ASSERT_GE(alignment, 0);
864 }
865
866 /**
867 * @tc.number : VIDEO_SWDEC_CAP_API_3400
868 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
869 * @tc.desc : api test
870 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3400, TestSize.Level2)871 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3400, TestSize.Level2)
872 {
873 OH_AVErrCode ret = AV_ERR_OK;
874 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
875 ASSERT_NE(nullptr, capability);
876 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
877 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
878 }
879
880 /**
881 * @tc.number : VIDEO_SWDEC_CAP_API_3500
882 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
883 * @tc.desc : api test
884 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3500, TestSize.Level2)885 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3500, TestSize.Level2)
886 {
887 OH_AVErrCode ret = AV_ERR_OK;
888 int32_t alignment = 0;
889 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
890 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
891 }
892
893 /**
894 * @tc.number : VIDEO_SWDEC_CAP_API_3600
895 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
896 * @tc.desc : api test
897 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3600, TestSize.Level2)898 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3600, TestSize.Level2)
899 {
900 OH_AVErrCode ret = AV_ERR_OK;
901 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
902 ASSERT_NE(nullptr, capability);
903 int32_t alignment = 0;
904 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
905 cout << "HeightAlignment " << alignment << endl;
906 ASSERT_EQ(AV_ERR_OK, ret);
907 ASSERT_GE(alignment, 0);
908 }
909
910 /**
911 * @tc.number : VIDEO_SWDEC_CAP_API_3700
912 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
913 * @tc.desc : api test
914 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3700, TestSize.Level2)915 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3700, TestSize.Level2)
916 {
917 OH_AVErrCode ret = AV_ERR_OK;
918 OH_AVRange range;
919 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
920 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
921 ASSERT_NE(nullptr, capability);
922 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range);
923 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
924 }
925
926 /**
927 * @tc.number : VIDEO_SWDEC_CAP_API_3800
928 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
929 * @tc.desc : api test
930 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3800, TestSize.Level2)931 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3800, TestSize.Level2)
932 {
933 OH_AVErrCode ret = AV_ERR_OK;
934 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
935 ASSERT_NE(nullptr, capability);
936 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, nullptr);
937 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
938 }
939
940 /**
941 * @tc.number : VIDEO_SWDEC_CAP_API_3900
942 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
943 * @tc.desc : api test
944 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3900, TestSize.Level2)945 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3900, TestSize.Level2)
946 {
947 OH_AVErrCode ret = AV_ERR_OK;
948 OH_AVRange range;
949 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
950 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
951 ASSERT_NE(nullptr, capability);
952 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
953 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
954 }
955
956 /**
957 * @tc.number : VIDEO_SWDEC_CAP_API_4000
958 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
959 * @tc.desc : api test
960 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4000, TestSize.Level2)961 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4000, TestSize.Level2)
962 {
963 OH_AVErrCode ret = AV_ERR_OK;
964 OH_AVRange range;
965 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
966 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
967 ASSERT_NE(nullptr, capability);
968 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
969 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
970 ASSERT_EQ(AV_ERR_OK, ret);
971 ASSERT_EQ(true, (range.minVal >= 0));
972 ASSERT_EQ(true, (range.maxVal > 0));
973 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
974 ASSERT_NE(nullptr, vdec_);
975 format = OH_AVFormat_Create();
976 ASSERT_NE(nullptr, format);
977 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
978 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
979 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
980 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
981 OH_VideoDecoder_Destroy(vdec_);
982 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
983 ASSERT_NE(nullptr, vdec_);
984 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
985 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
986 }
987
988 /**
989 * @tc.number : VIDEO_SWDEC_CAP_API_4100
990 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
991 * @tc.desc : api test
992 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)993 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)
994 {
995 OH_AVErrCode ret = AV_ERR_OK;
996 OH_AVRange range;
997 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
998 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
999 ASSERT_NE(nullptr, capability);
1000 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1001 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1002 }
1003
1004 /**
1005 * @tc.number : VIDEO_SWDEC_CAP_API_4200
1006 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1007 * @tc.desc : api test
1008 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)1009 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)
1010 {
1011 OH_AVErrCode ret = AV_ERR_OK;
1012 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1013 ASSERT_NE(nullptr, capability);
1014 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1015 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1016 }
1017
1018 /**
1019 * @tc.number : VIDEO_SWDEC_CAP_API_4300
1020 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1021 * @tc.desc : api test
1022 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)1023 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)
1024 {
1025 OH_AVErrCode ret = AV_ERR_OK;
1026 OH_AVRange range;
1027 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1028 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1029 ASSERT_NE(nullptr, capability);
1030 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1031 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1032 }
1033
1034 /**
1035 * @tc.number : VIDEO_SWDEC_CAP_API_4400
1036 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1037 * @tc.desc : api test
1038 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)1039 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)
1040 {
1041 OH_AVErrCode ret = AV_ERR_OK;
1042 OH_AVRange range;
1043 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1044 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1045 ASSERT_NE(nullptr, capability);
1046 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1047 ASSERT_EQ(AV_ERR_OK, ret);
1048 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1049 ASSERT_EQ(true, (range.minVal >= 0));
1050 ASSERT_EQ(true, (range.maxVal > 0));
1051 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1052 ASSERT_NE(nullptr, vdec_);
1053 format = OH_AVFormat_Create();
1054 ASSERT_NE(nullptr, format);
1055 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1056 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1057 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1058 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1059 OH_VideoDecoder_Destroy(vdec_);
1060 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1061 ASSERT_NE(nullptr, vdec_);
1062 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1063 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1064 }
1065
1066 /**
1067 * @tc.number : VIDEO_SWDEC_CAP_API_4500
1068 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1069 * @tc.desc : api test
1070 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)1071 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)
1072 {
1073 OH_AVErrCode ret = AV_ERR_OK;
1074 OH_AVRange range;
1075 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1076 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1077 }
1078
1079 /**
1080 * @tc.number : VIDEO_SWDEC_CAP_API_4600
1081 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1082 * @tc.desc : api test
1083 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)1084 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)
1085 {
1086 OH_AVErrCode ret = AV_ERR_OK;
1087 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1088 ASSERT_NE(nullptr, capability);
1089 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1090 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1091 }
1092
1093 /**
1094 * @tc.number : VIDEO_SWDEC_CAP_API_4700
1095 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1096 * @tc.desc : api test
1097 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, TestSize.Level2)1098 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, 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, SOFTWARE);
1104 ASSERT_NE(nullptr, capability);
1105 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1106 ASSERT_EQ(AV_ERR_OK, ret);
1107 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1108 ASSERT_GE(range.minVal, 0);
1109 ASSERT_GT(range.maxVal, 0);
1110 }
1111
1112 /**
1113 * @tc.number : VIDEO_SWDEC_CAP_API_4800
1114 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1115 * @tc.desc : api test
1116 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)1117 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)
1118 {
1119 OH_AVErrCode ret = AV_ERR_OK;
1120 OH_AVRange range;
1121 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1122 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1123 }
1124
1125 /**
1126 * @tc.number : VIDEO_SWDEC_CAP_API_4900
1127 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1128 * @tc.desc : api test
1129 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)1130 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)
1131 {
1132 OH_AVErrCode ret = AV_ERR_OK;
1133 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1134 ASSERT_NE(nullptr, capability);
1135 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1136 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1137 }
1138
1139 /**
1140 * @tc.number : VIDEO_SWDEC_CAP_API_5000
1141 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1142 * @tc.desc : api test
1143 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)1144 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)
1145 {
1146 OH_AVErrCode ret = AV_ERR_OK;
1147 OH_AVRange widthRange;
1148 OH_AVRange heightRange;
1149 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1150 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1151 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1152 ASSERT_NE(nullptr, capability);
1153 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1154 ASSERT_EQ(AV_ERR_OK, ret);
1155 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1156 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1157 ASSERT_EQ(AV_ERR_OK, ret);
1158 cout << "minval=" << widthRange.minVal << " maxval=" << widthRange.maxVal << endl;
1159 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1160 ASSERT_NE(nullptr, vdec_);
1161 format = OH_AVFormat_Create();
1162 ASSERT_NE(nullptr, format);
1163 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1164 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.minVal - 1);
1165 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1166 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1167 OH_VideoDecoder_Destroy(vdec_);
1168 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1169 ASSERT_NE(nullptr, vdec_);
1170 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.maxVal + 1);
1171 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1172 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1173 }
1174
1175 /**
1176 * @tc.number : VIDEO_SWDEC_CAP_API_5100
1177 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1178 * @tc.desc : api test
1179 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)1180 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)
1181 {
1182 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1183 ASSERT_NE(nullptr, capability);
1184 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1185 }
1186
1187 /**
1188 * @tc.number : VIDEO_SWDEC_CAP_API_5200
1189 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1190 * @tc.desc : api test
1191 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)1192 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)
1193 {
1194 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1195 ASSERT_NE(nullptr, capability);
1196 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1197 }
1198 /**
1199 * @tc.number : VIDEO_SWDEC_CAP_API_5300
1200 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1201 * @tc.desc : api test
1202 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)1203 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)
1204 {
1205 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1206 }
1207 /**
1208 * @tc.number : VIDEO_SWDEC_CAP_API_9400
1209 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1210 * @tc.desc : api test
1211 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)1212 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)
1213 {
1214 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1215 ASSERT_NE(nullptr, capability);
1216 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 7680, 4320));
1217 }
1218 /**
1219 * @tc.number : VIDEO_SWDEC_CAP_API_5400
1220 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1221 * @tc.desc : api test
1222 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)1223 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)
1224 {
1225 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1226 ASSERT_NE(nullptr, capability);
1227 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1228 }
1229
1230 /**
1231 * @tc.number : VIDEO_SWDEC_CAP_API_5500
1232 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1233 * @tc.desc : api test
1234 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)1235 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)
1236 {
1237 OH_AVErrCode ret = AV_ERR_OK;
1238 OH_AVRange range;
1239 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1240 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1241 }
1242
1243 /**
1244 * @tc.number : VIDEO_SWDEC_CAP_API_5600
1245 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1246 * @tc.desc : api test
1247 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)1248 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)
1249 {
1250 OH_AVErrCode ret = AV_ERR_OK;
1251 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1252 ASSERT_NE(nullptr, capability);
1253 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1254 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1255 }
1256
1257 /**
1258 * @tc.number : VIDEO_SWDEC_CAP_API_5700
1259 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1260 * @tc.desc : api test
1261 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)1262 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)
1263 {
1264 OH_AVErrCode ret = AV_ERR_OK;
1265 OH_AVRange range;
1266 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1267 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1268 ASSERT_NE(nullptr, capability);
1269 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1270 ASSERT_EQ(AV_ERR_OK, ret);
1271 ASSERT_GE(range.minVal, 0);
1272 ASSERT_GT(range.maxVal, 0);
1273 }
1274
1275 /**
1276 * @tc.number : VIDEO_SWDEC_CAP_API_5800
1277 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1278 * @tc.desc : api test
1279 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)1280 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)
1281 {
1282 OH_AVErrCode ret = AV_ERR_OK;
1283 OH_AVRange range;
1284 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1285 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1286 }
1287
1288 /**
1289 * @tc.number : VIDEO_SWDEC_CAP_API_5900
1290 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1291 * @tc.desc : api test
1292 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)1293 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)
1294 {
1295 OH_AVErrCode ret = AV_ERR_OK;
1296 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1297 ASSERT_NE(nullptr, capability);
1298 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1299 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1300 }
1301
1302 /**
1303 * @tc.number : VIDEO_SWDEC_CAP_API_6000
1304 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1305 * @tc.desc : api test
1306 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)1307 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)
1308 {
1309 OH_AVErrCode ret = AV_ERR_OK;
1310 OH_AVRange range;
1311 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1312 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1313 ASSERT_NE(nullptr, capability);
1314 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1315 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1316 }
1317
1318 /**
1319 * @tc.number : VIDEO_SWDEC_CAP_API_6100
1320 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1321 * @tc.desc : api test
1322 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)1323 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, 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_AVC, false, SOFTWARE);
1329 ASSERT_NE(nullptr, capability);
1330 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1331 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1332 }
1333
1334 /**
1335 * @tc.number : VIDEO_SWDEC_CAP_API_6200
1336 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1337 * @tc.desc : api test
1338 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)1339 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)
1340 {
1341 OH_AVErrCode ret = AV_ERR_OK;
1342 OH_AVRange range;
1343 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1344 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1345 ASSERT_NE(nullptr, capability);
1346 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1347 ASSERT_EQ(AV_ERR_OK, ret);
1348 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1349 ASSERT_GE(range.minVal, 0);
1350 ASSERT_GT(range.maxVal, 0);
1351
1352 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1353 ASSERT_EQ(AV_ERR_OK, ret);
1354 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1355 ASSERT_GE(range.minVal, 0);
1356 ASSERT_GT(range.maxVal, 0);
1357 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 3840, 2160, &range);
1358 ASSERT_EQ(AV_ERR_OK, ret);
1359 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1360 ASSERT_GE(range.minVal, 0);
1361 ASSERT_GT(range.maxVal, 0);
1362 }
1363
1364 /**
1365 * @tc.number : VIDEO_SWDEC_CAP_API_6300
1366 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1367 * @tc.desc : api test
1368 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)1369 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)
1370 {
1371 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1372 ASSERT_NE(nullptr, capability);
1373 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1374 }
1375
1376 /**
1377 * @tc.number : VIDEO_SWDEC_CAP_API_6400
1378 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1379 * @tc.desc : api test
1380 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)1381 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)
1382 {
1383 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1384 ASSERT_NE(nullptr, capability);
1385 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1386 }
1387
1388 /**
1389 * @tc.number : VIDEO_SWDEC_CAP_API_6500
1390 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1391 * @tc.desc : api test
1392 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)1393 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)
1394 {
1395 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1396 ASSERT_NE(nullptr, capability);
1397 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1398 }
1399
1400 /**
1401 * @tc.number : VIDEO_SWDEC_CAP_API_6600
1402 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1403 * @tc.desc : api test
1404 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)1405 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)
1406 {
1407 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1408 }
1409
1410 /**
1411 * @tc.number : VIDEO_SWDEC_CAP_API_6700
1412 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1413 * @tc.desc : api test
1414 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)1415 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)
1416 {
1417 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1418 ASSERT_NE(nullptr, capability);
1419 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1420 }
1421
1422 /**
1423 * @tc.number : VIDEO_SWDEC_CAP_API_6800
1424 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1425 * @tc.desc : api test
1426 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)1427 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)
1428 {
1429 OH_AVErrCode ret = AV_ERR_OK;
1430 const int32_t *pixelFormat = nullptr;
1431 uint32_t pixelFormatNum = 0;
1432 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1433 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1434 }
1435
1436 /**
1437 * @tc.number : VIDEO_SWDEC_CAP_API_6900
1438 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1439 * @tc.desc : api test
1440 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)1441 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)
1442 {
1443 OH_AVErrCode ret = AV_ERR_OK;
1444 uint32_t pixelFormatNum = 0;
1445 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1446 ASSERT_NE(nullptr, capability);
1447 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1448 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1449 }
1450
1451 /**
1452 * @tc.number : VIDEO_SWDEC_CAP_API_7000
1453 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1454 * @tc.desc : api test
1455 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)1456 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)
1457 {
1458 OH_AVErrCode ret = AV_ERR_OK;
1459 const int32_t *pixelFormat = nullptr;
1460 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1461 ASSERT_NE(nullptr, capability);
1462 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1463 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1464 }
1465
1466 /**
1467 * @tc.number : VIDEO_SWDEC_CAP_API_7100
1468 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1469 * @tc.desc : api test
1470 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)1471 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)
1472 {
1473 OH_AVErrCode ret = AV_ERR_OK;
1474 const int32_t *pixelFormat = nullptr;
1475 uint32_t pixelFormatNum = 0;
1476 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1477 ASSERT_NE(nullptr, capability);
1478 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1479 ASSERT_NE(nullptr, pixelFormat);
1480 ASSERT_EQ(pixelFormatNum, PIXFORMAT_NUM);
1481 ASSERT_EQ(AV_ERR_OK, ret);
1482 for (int i = 0; i < pixelFormatNum; i++) {
1483 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1484 ASSERT_NE(nullptr, vdec_);
1485 format = OH_AVFormat_Create();
1486 ASSERT_NE(nullptr, format);
1487 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1488 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1489 EXPECT_EQ(pixelFormat[i], i == pixelFormatNum - 1 ? i + 2 : i + 1);
1490 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1491 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1492 OH_AVFormat_Destroy(format);
1493 OH_VideoDecoder_Destroy(vdec_);
1494 }
1495 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1496 ASSERT_NE(nullptr, vdec_);
1497 format = OH_AVFormat_Create();
1498 ASSERT_NE(nullptr, format);
1499 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1500 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1501 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1502 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1503 }
1504
1505 /**
1506 * @tc.number : VIDEO_SWDEC_CAP_API_7200
1507 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1508 * @tc.desc : api test
1509 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7200, TestSize.Level2)1510 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7200, TestSize.Level2)
1511 {
1512 OH_AVErrCode ret = AV_ERR_OK;
1513 const int32_t *profiles = nullptr;
1514 uint32_t profileNum = 0;
1515 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1516 ASSERT_NE(nullptr, capability);
1517 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1518 ASSERT_EQ(AV_ERR_OK, ret);
1519 ASSERT_GT(profileNum, 0);
1520 ASSERT_NE(nullptr, profiles);
1521 for (int i = 0; i < profileNum; i++) {
1522 EXPECT_GE(profiles[i], 0);
1523 }
1524 }
1525
1526 /**
1527 * @tc.number : VIDEO_SWDEC_CAP_API_7300
1528 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1529 * @tc.desc : api test
1530 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7300, TestSize.Level2)1531 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7300, TestSize.Level2)
1532 {
1533 OH_AVErrCode ret = AV_ERR_OK;
1534 const int32_t *levels = nullptr;
1535 uint32_t levelNum = 0;
1536 const int32_t *profiles = nullptr;
1537 uint32_t profileNum = 0;
1538 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1539 ASSERT_NE(nullptr, capability);
1540 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1541 ASSERT_EQ(AV_ERR_OK, ret);
1542 ASSERT_GT(profileNum, 0);
1543 ASSERT_NE(nullptr, profiles);
1544 for (int i = 0; i < profileNum; i++) {
1545 EXPECT_GE(profiles[i], 0);
1546 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
1547 ASSERT_EQ(AV_ERR_OK, ret);
1548 ASSERT_NE(nullptr, levels);
1549 EXPECT_GT(levelNum, 0);
1550 for (int j = 0; j < levelNum; j++) {
1551 EXPECT_GE(levels[j], 0);
1552 }
1553 }
1554 }
1555
1556 /**
1557 * @tc.number : VIDEO_SWDEC_CAP_API_7400
1558 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1559 * @tc.desc : api test
1560 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7400, TestSize.Level2)1561 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7400, TestSize.Level2)
1562 {
1563 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1564 ASSERT_NE(nullptr, capability);
1565 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
1566 }
1567 } // namespace