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