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