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