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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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_OK, 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 */
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 */
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 */
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_OK, 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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 const char *codecName = OH_AVCapability_GetName(capability);
969 ASSERT_NE(nullptr, codecName);
970 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
971 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
972 ASSERT_EQ(AV_ERR_OK, ret);
973 ASSERT_EQ(true, (range.minVal >= 0));
974 ASSERT_EQ(true, (range.maxVal > 0));
975 vdec_ = OH_VideoDecoder_CreateByName(codecName);
976 ASSERT_NE(nullptr, vdec_);
977 format = OH_AVFormat_Create();
978 ASSERT_NE(nullptr, format);
979 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
980 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
981 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
982 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
983 OH_VideoDecoder_Destroy(vdec_);
984 vdec_ = OH_VideoDecoder_CreateByName(codecName);
985 ASSERT_NE(nullptr, vdec_);
986 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
987 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
988 }
989
990 /**
991 * @tc.number : VIDEO_SWDEC_CAP_API_4100
992 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
993 * @tc.desc : api test
994 */
995 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)
996 {
997 OH_AVErrCode ret = AV_ERR_OK;
998 OH_AVRange range;
999 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1000 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1001 ASSERT_NE(nullptr, capability);
1002 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1003 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1004 }
1005
1006 /**
1007 * @tc.number : VIDEO_SWDEC_CAP_API_4200
1008 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1009 * @tc.desc : api test
1010 */
1011 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)
1012 {
1013 OH_AVErrCode ret = AV_ERR_OK;
1014 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1015 ASSERT_NE(nullptr, capability);
1016 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1017 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1018 }
1019
1020 /**
1021 * @tc.number : VIDEO_SWDEC_CAP_API_4300
1022 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1023 * @tc.desc : api test
1024 */
1025 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)
1026 {
1027 OH_AVErrCode ret = AV_ERR_OK;
1028 OH_AVRange range;
1029 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1030 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1031 ASSERT_NE(nullptr, capability);
1032 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1033 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1034 }
1035
1036 /**
1037 * @tc.number : VIDEO_SWDEC_CAP_API_4400
1038 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1039 * @tc.desc : api test
1040 */
1041 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)
1042 {
1043 OH_AVErrCode ret = AV_ERR_OK;
1044 OH_AVRange range;
1045 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1046 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1047 ASSERT_NE(nullptr, capability);
1048 const char *codecName = OH_AVCapability_GetName(capability);
1049 ASSERT_NE(nullptr, codecName);
1050 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1051 ASSERT_EQ(AV_ERR_OK, ret);
1052 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1053 ASSERT_EQ(true, (range.minVal >= 0));
1054 ASSERT_EQ(true, (range.maxVal > 0));
1055 vdec_ = OH_VideoDecoder_CreateByName(codecName);
1056 ASSERT_NE(nullptr, vdec_);
1057 format = OH_AVFormat_Create();
1058 ASSERT_NE(nullptr, format);
1059 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1060 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1061 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1062 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1063 OH_VideoDecoder_Destroy(vdec_);
1064 vdec_ = OH_VideoDecoder_CreateByName(codecName);
1065 ASSERT_NE(nullptr, vdec_);
1066 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1067 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1068 }
1069
1070 /**
1071 * @tc.number : VIDEO_SWDEC_CAP_API_4500
1072 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1073 * @tc.desc : api test
1074 */
1075 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)
1076 {
1077 OH_AVErrCode ret = AV_ERR_OK;
1078 OH_AVRange range;
1079 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1080 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1081 }
1082
1083 /**
1084 * @tc.number : VIDEO_SWDEC_CAP_API_4600
1085 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1086 * @tc.desc : api test
1087 */
1088 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)
1089 {
1090 OH_AVErrCode ret = AV_ERR_OK;
1091 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1092 ASSERT_NE(nullptr, capability);
1093 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1094 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1095 }
1096
1097 /**
1098 * @tc.number : VIDEO_SWDEC_CAP_API_4700
1099 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1100 * @tc.desc : api test
1101 */
1102 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, TestSize.Level2)
1103 {
1104 OH_AVErrCode ret = AV_ERR_OK;
1105 OH_AVRange range;
1106 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1107 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1108 ASSERT_NE(nullptr, capability);
1109 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1110 ASSERT_EQ(AV_ERR_OK, ret);
1111 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1112 ASSERT_GE(range.minVal, 0);
1113 ASSERT_GT(range.maxVal, 0);
1114 }
1115
1116 /**
1117 * @tc.number : VIDEO_SWDEC_CAP_API_4800
1118 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1119 * @tc.desc : api test
1120 */
1121 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)
1122 {
1123 OH_AVErrCode ret = AV_ERR_OK;
1124 OH_AVRange range;
1125 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1126 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1127 }
1128
1129 /**
1130 * @tc.number : VIDEO_SWDEC_CAP_API_4900
1131 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1132 * @tc.desc : api test
1133 */
1134 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)
1135 {
1136 OH_AVErrCode ret = AV_ERR_OK;
1137 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1138 ASSERT_NE(nullptr, capability);
1139 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1140 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1141 }
1142
1143 /**
1144 * @tc.number : VIDEO_SWDEC_CAP_API_5000
1145 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1146 * @tc.desc : api test
1147 */
1148 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)
1149 {
1150 OH_AVErrCode ret = AV_ERR_OK;
1151 OH_AVRange widthRange;
1152 OH_AVRange heightRange;
1153 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1154 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1155 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1156 ASSERT_NE(nullptr, capability);
1157 const char *codecName = OH_AVCapability_GetName(capability);
1158 ASSERT_NE(nullptr, codecName);
1159 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1160 ASSERT_EQ(AV_ERR_OK, ret);
1161 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
1162 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1163 ASSERT_EQ(AV_ERR_OK, ret);
1164 cout << "minval=" << widthRange.minVal << " maxval=" << widthRange.maxVal << endl;
1165 vdec_ = OH_VideoDecoder_CreateByName(codecName);
1166 ASSERT_NE(nullptr, vdec_);
1167 format = OH_AVFormat_Create();
1168 ASSERT_NE(nullptr, format);
1169 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1170 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.minVal - 1);
1171 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1172 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1173 OH_VideoDecoder_Destroy(vdec_);
1174 vdec_ = OH_VideoDecoder_CreateByName(codecName);
1175 ASSERT_NE(nullptr, vdec_);
1176 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.maxVal + 1);
1177 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1178 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1179 }
1180
1181 /**
1182 * @tc.number : VIDEO_SWDEC_CAP_API_5100
1183 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1184 * @tc.desc : api test
1185 */
1186 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)
1187 {
1188 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1189 ASSERT_NE(nullptr, capability);
1190 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1191 }
1192
1193 /**
1194 * @tc.number : VIDEO_SWDEC_CAP_API_5200
1195 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1196 * @tc.desc : api test
1197 */
1198 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)
1199 {
1200 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1201 ASSERT_NE(nullptr, capability);
1202 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1203 }
1204 /**
1205 * @tc.number : VIDEO_SWDEC_CAP_API_5300
1206 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1207 * @tc.desc : api test
1208 */
1209 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)
1210 {
1211 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1212 }
1213 /**
1214 * @tc.number : VIDEO_SWDEC_CAP_API_9400
1215 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1216 * @tc.desc : api test
1217 */
1218 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)
1219 {
1220 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1221 ASSERT_NE(nullptr, capability);
1222 OH_AVRange heightRange;
1223 OH_AVRange widthRange;
1224 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoHeightRange(capability, &heightRange));
1225 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoWidthRange(capability, &widthRange));
1226 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, widthRange.maxVal + 1, heightRange.maxVal + 1));
1227 }
1228 /**
1229 * @tc.number : VIDEO_SWDEC_CAP_API_5400
1230 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1231 * @tc.desc : api test
1232 */
1233 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)
1234 {
1235 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1236 ASSERT_NE(nullptr, capability);
1237 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1238 }
1239
1240 /**
1241 * @tc.number : VIDEO_SWDEC_CAP_API_5500
1242 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1243 * @tc.desc : api test
1244 */
1245 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)
1246 {
1247 OH_AVErrCode ret = AV_ERR_OK;
1248 OH_AVRange range;
1249 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1250 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1251 }
1252
1253 /**
1254 * @tc.number : VIDEO_SWDEC_CAP_API_5600
1255 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1256 * @tc.desc : api test
1257 */
1258 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)
1259 {
1260 OH_AVErrCode ret = AV_ERR_OK;
1261 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1262 ASSERT_NE(nullptr, capability);
1263 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1264 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1265 }
1266
1267 /**
1268 * @tc.number : VIDEO_SWDEC_CAP_API_5700
1269 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1270 * @tc.desc : api test
1271 */
1272 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)
1273 {
1274 OH_AVErrCode ret = AV_ERR_OK;
1275 OH_AVRange range;
1276 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1277 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1278 ASSERT_NE(nullptr, capability);
1279 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1280 ASSERT_EQ(AV_ERR_OK, ret);
1281 ASSERT_GE(range.minVal, 0);
1282 ASSERT_GT(range.maxVal, 0);
1283 }
1284
1285 /**
1286 * @tc.number : VIDEO_SWDEC_CAP_API_5800
1287 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1288 * @tc.desc : api test
1289 */
1290 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)
1291 {
1292 OH_AVErrCode ret = AV_ERR_OK;
1293 OH_AVRange range;
1294 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1295 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1296 }
1297
1298 /**
1299 * @tc.number : VIDEO_SWDEC_CAP_API_5900
1300 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1301 * @tc.desc : api test
1302 */
1303 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)
1304 {
1305 OH_AVErrCode ret = AV_ERR_OK;
1306 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1307 ASSERT_NE(nullptr, capability);
1308 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1309 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1310 }
1311
1312 /**
1313 * @tc.number : VIDEO_SWDEC_CAP_API_6000
1314 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1315 * @tc.desc : api test
1316 */
1317 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, 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(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1323 ASSERT_NE(nullptr, capability);
1324 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1325 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1326 }
1327
1328 /**
1329 * @tc.number : VIDEO_SWDEC_CAP_API_6100
1330 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1331 * @tc.desc : api test
1332 */
1333 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)
1334 {
1335 OH_AVErrCode ret = AV_ERR_OK;
1336 OH_AVRange range;
1337 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1338 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1339 ASSERT_NE(nullptr, capability);
1340 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1341 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1342 }
1343
1344 /**
1345 * @tc.number : VIDEO_SWDEC_CAP_API_6200
1346 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1347 * @tc.desc : api test
1348 */
1349 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)
1350 {
1351 OH_AVErrCode ret = AV_ERR_OK;
1352 OH_AVRange range;
1353 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1354 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1355 ASSERT_NE(nullptr, capability);
1356 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1357 ASSERT_EQ(AV_ERR_OK, ret);
1358 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1359 ASSERT_GE(range.minVal, 0);
1360 ASSERT_GT(range.maxVal, 0);
1361
1362 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1363 ASSERT_EQ(AV_ERR_OK, ret);
1364 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1365 ASSERT_GE(range.minVal, 0);
1366 ASSERT_GT(range.maxVal, 0);
1367 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 3840, 2160, &range);
1368 ASSERT_EQ(AV_ERR_OK, ret);
1369 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1370 ASSERT_GE(range.minVal, 0);
1371 ASSERT_GT(range.maxVal, 0);
1372 }
1373
1374 /**
1375 * @tc.number : VIDEO_SWDEC_CAP_API_6300
1376 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1377 * @tc.desc : api test
1378 */
1379 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)
1380 {
1381 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1382 ASSERT_NE(nullptr, capability);
1383 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1384 }
1385
1386 /**
1387 * @tc.number : VIDEO_SWDEC_CAP_API_6400
1388 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1389 * @tc.desc : api test
1390 */
1391 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)
1392 {
1393 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1394 ASSERT_NE(nullptr, capability);
1395 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1396 }
1397
1398 /**
1399 * @tc.number : VIDEO_SWDEC_CAP_API_6500
1400 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1401 * @tc.desc : api test
1402 */
1403 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)
1404 {
1405 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1406 ASSERT_NE(nullptr, capability);
1407 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1408 }
1409
1410 /**
1411 * @tc.number : VIDEO_SWDEC_CAP_API_6600
1412 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1413 * @tc.desc : api test
1414 */
1415 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)
1416 {
1417 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1418 }
1419
1420 /**
1421 * @tc.number : VIDEO_SWDEC_CAP_API_6700
1422 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1423 * @tc.desc : api test
1424 */
1425 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)
1426 {
1427 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1428 ASSERT_NE(nullptr, capability);
1429 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1430 }
1431
1432 /**
1433 * @tc.number : VIDEO_SWDEC_CAP_API_6800
1434 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1435 * @tc.desc : api test
1436 */
1437 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)
1438 {
1439 OH_AVErrCode ret = AV_ERR_OK;
1440 const int32_t *pixelFormat = nullptr;
1441 uint32_t pixelFormatNum = 0;
1442 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1443 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1444 }
1445
1446 /**
1447 * @tc.number : VIDEO_SWDEC_CAP_API_6900
1448 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1449 * @tc.desc : api test
1450 */
1451 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)
1452 {
1453 OH_AVErrCode ret = AV_ERR_OK;
1454 uint32_t pixelFormatNum = 0;
1455 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1456 ASSERT_NE(nullptr, capability);
1457 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1458 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1459 }
1460
1461 /**
1462 * @tc.number : VIDEO_SWDEC_CAP_API_7000
1463 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1464 * @tc.desc : api test
1465 */
1466 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)
1467 {
1468 OH_AVErrCode ret = AV_ERR_OK;
1469 const int32_t *pixelFormat = nullptr;
1470 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1471 ASSERT_NE(nullptr, capability);
1472 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1473 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1474 }
1475
1476 /**
1477 * @tc.number : VIDEO_SWDEC_CAP_API_7100
1478 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1479 * @tc.desc : api test
1480 */
1481 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)
1482 {
1483 OH_AVErrCode ret = AV_ERR_OK;
1484 const int32_t *pixelFormat = nullptr;
1485 uint32_t pixelFormatNum = 0;
1486 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1487 ASSERT_NE(nullptr, capability);
1488 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1489 ASSERT_NE(nullptr, pixelFormat);
1490 ASSERT_EQ(pixelFormatNum, PIXFORMAT_NUM);
1491 ASSERT_EQ(AV_ERR_OK, ret);
1492 for (int i = 0; i < pixelFormatNum; i++) {
1493 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1494 ASSERT_NE(nullptr, vdec_);
1495 format = OH_AVFormat_Create();
1496 ASSERT_NE(nullptr, format);
1497 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1498 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1499 EXPECT_EQ(pixelFormat[i], i == pixelFormatNum - 1 ? i + 2 : i + 1);
1500 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1501 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1502 OH_AVFormat_Destroy(format);
1503 OH_VideoDecoder_Destroy(vdec_);
1504 }
1505 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1506 ASSERT_NE(nullptr, vdec_);
1507 format = OH_AVFormat_Create();
1508 ASSERT_NE(nullptr, format);
1509 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1510 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1511 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1512 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1513 }
1514
1515 /**
1516 * @tc.number : VIDEO_SWDEC_CAP_API_7200
1517 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1518 * @tc.desc : api test
1519 */
1520 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7200, TestSize.Level2)
1521 {
1522 OH_AVErrCode ret = AV_ERR_OK;
1523 const int32_t *profiles = nullptr;
1524 uint32_t profileNum = 0;
1525 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1526 ASSERT_NE(nullptr, capability);
1527 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1528 ASSERT_EQ(AV_ERR_OK, ret);
1529 ASSERT_GT(profileNum, 0);
1530 ASSERT_NE(nullptr, profiles);
1531 for (int i = 0; i < profileNum; i++) {
1532 EXPECT_GE(profiles[i], 0);
1533 }
1534 }
1535
1536 /**
1537 * @tc.number : VIDEO_SWDEC_CAP_API_7300
1538 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1539 * @tc.desc : api test
1540 */
1541 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7300, TestSize.Level2)
1542 {
1543 OH_AVErrCode ret = AV_ERR_OK;
1544 const int32_t *levels = nullptr;
1545 uint32_t levelNum = 0;
1546 const int32_t *profiles = nullptr;
1547 uint32_t profileNum = 0;
1548 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1549 ASSERT_NE(nullptr, capability);
1550 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1551 ASSERT_EQ(AV_ERR_OK, ret);
1552 ASSERT_GT(profileNum, 0);
1553 ASSERT_NE(nullptr, profiles);
1554 for (int i = 0; i < profileNum; i++) {
1555 EXPECT_GE(profiles[i], 0);
1556 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
1557 ASSERT_EQ(AV_ERR_OK, ret);
1558 ASSERT_NE(nullptr, levels);
1559 EXPECT_GT(levelNum, 0);
1560 for (int j = 0; j < levelNum; j++) {
1561 EXPECT_GE(levels[j], 0);
1562 }
1563 }
1564 }
1565
1566 /**
1567 * @tc.number : VIDEO_SWDEC_CAP_API_7400
1568 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1569 * @tc.desc : api test
1570 */
1571 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7400, TestSize.Level2)
1572 {
1573 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1574 ASSERT_NE(nullptr, capability);
1575 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
1576 }
1577 } // namespace