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 #ifdef SUPPORT_DRM
35 #include "native_mediakeysession.h"
36 #include "native_mediakeysystem.h"
37 #endif
38
39 #define PIXFORMAT_NUM 4
40
41 using namespace std;
42 using namespace OHOS;
43 using namespace OHOS::Media;
44 using namespace testing::ext;
45 namespace OHOS {
46 namespace Media {
47 class SwdecApiNdkTest : public testing::Test {
48 public:
49 // SetUpTestCase: Called before all test cases
50 static void SetUpTestCase(void);
51 // TearDownTestCase: Called after all test case
52 static void TearDownTestCase(void);
53 // SetUp: Called before each test cases
54 void SetUp(void);
55 // TearDown: Called after each test cases
56 void TearDown(void);
57 };
58
59 OH_AVCodec *vdec_ = NULL;
60 OH_AVCapability *cap = nullptr;
61 const string INVALID_CODEC_NAME = "avdec_h264";
62 const string CODEC_NAME = "OH.Media.Codec.Decoder.Video.AVC";
63 VDecSignal *signal_;
64 constexpr uint32_t DEFAULT_WIDTH = 1920;
65 constexpr uint32_t DEFAULT_HEIGHT = 1080;
66 constexpr uint32_t DEFAULT_FRAME_RATE = 30;
67 OH_AVFormat *format;
SetUpTestCase()68 void SwdecApiNdkTest::SetUpTestCase() {}
TearDownTestCase()69 void SwdecApiNdkTest::TearDownTestCase() {}
SetUp()70 void SwdecApiNdkTest::SetUp()
71 {
72 signal_ = new VDecSignal();
73 }
TearDown()74 void SwdecApiNdkTest::TearDown()
75 {
76 if (format != nullptr) {
77 OH_AVFormat_Destroy(format);
78 format = nullptr;
79 }
80 if (signal_) {
81 delete signal_;
82 signal_ = nullptr;
83 }
84 if (vdec_ != NULL) {
85 OH_VideoDecoder_Destroy(vdec_);
86 vdec_ = nullptr;
87 }
88 }
89 } // namespace Media
90 } // namespace OHOS
91
92 namespace {
93 /**
94 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0100
95 * @tc.name : OH_VideoDecoder_FindDecoder para error
96 * @tc.desc : function test
97 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0100, TestSize.Level2)98 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0100, TestSize.Level2)
99 {
100 vdec_ = OH_VideoDecoder_CreateByMime(NULL);
101 ASSERT_EQ(NULL, vdec_);
102 }
103
104 /**
105 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0200
106 * @tc.name : OH_VideoDecoder_CreateByName para error
107 * @tc.desc : function test
108 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0200, TestSize.Level2)109 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0200, TestSize.Level2)
110 {
111 vdec_ = OH_VideoDecoder_CreateByName(NULL);
112 ASSERT_EQ(NULL, vdec_);
113 }
114
115 /**
116 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3300
117 * @tc.name : OH_VideoDecoder_SetCallback para error
118 * @tc.desc : function test
119 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3300, TestSize.Level2)120 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3300, TestSize.Level2)
121 {
122 OH_AVCodecAsyncCallback cb_;
123 cb_.onError = VdecError;
124 cb_.onStreamChanged = VdecFormatChanged;
125 cb_.onNeedInputData = VdecInputDataReady;
126 cb_.onNeedOutputData = VdecOutputDataReady;
127
128 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
129 }
130
131 /**
132 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1800
133 * @tc.name : OH_VideoDecoder_SetCallback para error
134 * @tc.desc : function test
135 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1800, TestSize.Level2)136 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1800, TestSize.Level2)
137 {
138 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
139 ASSERT_NE(NULL, vdec_);
140
141 OH_AVCodecAsyncCallback cb2_;
142 cb2_.onError = NULL;
143 cb2_.onStreamChanged = NULL;
144 cb2_.onNeedInputData = NULL;
145 cb2_.onNeedOutputData = NULL;
146 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb2_, static_cast<void *>(signal_)));
147 }
148
149 /**
150 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0300
151 * @tc.name : OH_VideoDecoder_SetCallback para error
152 * @tc.desc : function test
153 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0300, TestSize.Level2)154 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0300, TestSize.Level2)
155 {
156 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
157 OH_AVCodecAsyncCallback cb_;
158 cb_.onError = VdecError;
159 cb_.onStreamChanged = VdecFormatChanged;
160 cb_.onNeedInputData = VdecInputDataReady;
161 cb_.onNeedOutputData = VdecOutputDataReady;
162 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
163 }
164
165 /**
166 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0400
167 * @tc.name : OH_VideoDecoder_Destroy para error
168 * @tc.desc : function test
169 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0400, TestSize.Level2)170 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0400, TestSize.Level2)
171 {
172 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(NULL));
173 }
174
175 /**
176 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0500
177 * @tc.name : OH_VideoDecoder_Configure para error
178 * @tc.desc : function test
179 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0500, TestSize.Level2)180 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0500, TestSize.Level2)
181 {
182 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
183 ASSERT_NE(NULL, vdec_);
184 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, NULL));
185 }
186
187 /**
188 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1400
189 * @tc.name : OH_VideoDecoder_Configure para error
190 * @tc.desc : function test
191 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1400, TestSize.Level2)192 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1400, TestSize.Level2)
193 {
194 OH_AVFormat *format = OH_AVFormat_Create();
195 ASSERT_NE(NULL, format);
196 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
197 }
198
199 /**
200 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1400
201 * @tc.name : OH_VideoDecoder_Configure para error
202 * @tc.desc : function test
203 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5000, TestSize.Level2)204 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5000, TestSize.Level2)
205 {
206 OH_AVFormat *format = OH_AVFormat_Create();
207 ASSERT_NE(NULL, format);
208
209 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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0600, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0700, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0800, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0900, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1000, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_4100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1500, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1200, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1600, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1700, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2200, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2500, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2600, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2700, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2800, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2900, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3000, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3200, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0200, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0300, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0400, TestSize.Level2)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_INVALID_STATE, 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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0500, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0600, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0700, TestSize.Level2)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_INVALID_STATE, 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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0800, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_0900, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1000, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_API_1200, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0300, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0400, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0500, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0600, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0700, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0800, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0900, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1000, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3100, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3200, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3300, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3400, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3500, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3600, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3700, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3800, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3900, TestSize.Level2)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 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4000, TestSize.Level2)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_GE(range.minVal, 0);
1003 ASSERT_GT(range.maxVal, 0);
1004 }
1005
1006 /**
1007 * @tc.number : VIDEO_SWDEC_CAP_API_4100
1008 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1009 * @tc.desc : api test
1010 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)1011 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)
1012 {
1013 OH_AVErrCode ret = AV_ERR_OK;
1014 OH_AVRange range;
1015 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1016 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1017 ASSERT_NE(nullptr, capability);
1018 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1019 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1020 }
1021
1022 /**
1023 * @tc.number : VIDEO_SWDEC_CAP_API_4200
1024 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1025 * @tc.desc : api test
1026 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)1027 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)
1028 {
1029 OH_AVErrCode ret = AV_ERR_OK;
1030 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1031 ASSERT_NE(nullptr, capability);
1032 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1033 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1034 }
1035
1036 /**
1037 * @tc.number : VIDEO_SWDEC_CAP_API_4300
1038 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1039 * @tc.desc : api test
1040 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)1041 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)
1042 {
1043 OH_AVErrCode ret = AV_ERR_OK;
1044 OH_AVRange range;
1045 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1046 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1047 ASSERT_NE(nullptr, capability);
1048 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1049 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1050 }
1051
1052 /**
1053 * @tc.number : VIDEO_SWDEC_CAP_API_4400
1054 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1055 * @tc.desc : api test
1056 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)1057 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)
1058 {
1059 OH_AVErrCode ret = AV_ERR_OK;
1060 OH_AVRange range;
1061 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1062 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1063 ASSERT_NE(nullptr, capability);
1064 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1065 ASSERT_EQ(AV_ERR_OK, ret);
1066 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1067 ASSERT_GE(range.minVal, 0);
1068 ASSERT_GT(range.maxVal, 0);
1069 }
1070
1071 /**
1072 * @tc.number : VIDEO_SWDEC_CAP_API_4500
1073 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1074 * @tc.desc : api test
1075 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)1076 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)
1077 {
1078 OH_AVErrCode ret = AV_ERR_OK;
1079 OH_AVRange range;
1080 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1081 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1082 }
1083
1084 /**
1085 * @tc.number : VIDEO_SWDEC_CAP_API_4600
1086 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1087 * @tc.desc : api test
1088 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)1089 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)
1090 {
1091 OH_AVErrCode ret = AV_ERR_OK;
1092 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1093 ASSERT_NE(nullptr, capability);
1094 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1095 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1096 }
1097
1098 /**
1099 * @tc.number : VIDEO_SWDEC_CAP_API_4700
1100 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1101 * @tc.desc : api test
1102 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, TestSize.Level2)1103 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, TestSize.Level2)
1104 {
1105 OH_AVErrCode ret = AV_ERR_OK;
1106 OH_AVRange range;
1107 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1108 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1109 ASSERT_NE(nullptr, capability);
1110 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1111 ASSERT_EQ(AV_ERR_OK, ret);
1112 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1113 ASSERT_GE(range.minVal, 0);
1114 ASSERT_GT(range.maxVal, 0);
1115 }
1116
1117 /**
1118 * @tc.number : VIDEO_SWDEC_CAP_API_4800
1119 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1120 * @tc.desc : api test
1121 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)1122 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)
1123 {
1124 OH_AVErrCode ret = AV_ERR_OK;
1125 OH_AVRange range;
1126 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1127 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1128 }
1129
1130 /**
1131 * @tc.number : VIDEO_SWDEC_CAP_API_4900
1132 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1133 * @tc.desc : api test
1134 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)1135 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)
1136 {
1137 OH_AVErrCode ret = AV_ERR_OK;
1138 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1139 ASSERT_NE(nullptr, capability);
1140 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1141 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1142 }
1143
1144 /**
1145 * @tc.number : VIDEO_SWDEC_CAP_API_5000
1146 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1147 * @tc.desc : api test
1148 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)1149 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)
1150 {
1151 OH_AVErrCode ret = AV_ERR_OK;
1152 OH_AVRange range;
1153 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1154 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1155 ASSERT_NE(nullptr, capability);
1156 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
1157 ASSERT_EQ(AV_ERR_OK, ret);
1158 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1159 ASSERT_GE(range.minVal, 0);
1160 ASSERT_GT(range.maxVal, 0);
1161 }
1162
1163 /**
1164 * @tc.number : VIDEO_SWDEC_CAP_API_5100
1165 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1166 * @tc.desc : api test
1167 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)1168 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)
1169 {
1170 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1171 ASSERT_NE(nullptr, capability);
1172 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1173 }
1174
1175 /**
1176 * @tc.number : VIDEO_SWDEC_CAP_API_5200
1177 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1178 * @tc.desc : api test
1179 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)1180 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)
1181 {
1182 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1183 ASSERT_NE(nullptr, capability);
1184 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1185 }
1186 /**
1187 * @tc.number : VIDEO_SWDEC_CAP_API_5300
1188 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1189 * @tc.desc : api test
1190 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)1191 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)
1192 {
1193 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1194 }
1195 /**
1196 * @tc.number : VIDEO_SWDEC_CAP_API_9400
1197 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1198 * @tc.desc : api test
1199 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)1200 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)
1201 {
1202 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1203 ASSERT_NE(nullptr, capability);
1204 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 7680, 4320));
1205 }
1206 /**
1207 * @tc.number : VIDEO_SWDEC_CAP_API_5400
1208 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1209 * @tc.desc : api test
1210 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)1211 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, 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(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1216 }
1217
1218 /**
1219 * @tc.number : VIDEO_SWDEC_CAP_API_5500
1220 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1221 * @tc.desc : api test
1222 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)1223 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)
1224 {
1225 OH_AVErrCode ret = AV_ERR_OK;
1226 OH_AVRange range;
1227 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1228 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1229 }
1230
1231 /**
1232 * @tc.number : VIDEO_SWDEC_CAP_API_5600
1233 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1234 * @tc.desc : api test
1235 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)1236 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)
1237 {
1238 OH_AVErrCode ret = AV_ERR_OK;
1239 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1240 ASSERT_NE(nullptr, capability);
1241 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1242 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1243 }
1244
1245 /**
1246 * @tc.number : VIDEO_SWDEC_CAP_API_5700
1247 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1248 * @tc.desc : api test
1249 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)1250 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)
1251 {
1252 OH_AVErrCode ret = AV_ERR_OK;
1253 OH_AVRange range;
1254 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1255 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1256 ASSERT_NE(nullptr, capability);
1257 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1258 ASSERT_EQ(AV_ERR_OK, ret);
1259 ASSERT_GE(range.minVal, 0);
1260 ASSERT_GT(range.maxVal, 0);
1261 }
1262
1263 /**
1264 * @tc.number : VIDEO_SWDEC_CAP_API_5800
1265 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1266 * @tc.desc : api test
1267 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)1268 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)
1269 {
1270 OH_AVErrCode ret = AV_ERR_OK;
1271 OH_AVRange range;
1272 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1273 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1274 }
1275
1276 /**
1277 * @tc.number : VIDEO_SWDEC_CAP_API_5900
1278 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1279 * @tc.desc : api test
1280 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)1281 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)
1282 {
1283 OH_AVErrCode ret = AV_ERR_OK;
1284 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1285 ASSERT_NE(nullptr, capability);
1286 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1287 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1288 }
1289
1290 /**
1291 * @tc.number : VIDEO_SWDEC_CAP_API_6000
1292 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1293 * @tc.desc : api test
1294 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)1295 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)
1296 {
1297 OH_AVErrCode ret = AV_ERR_OK;
1298 OH_AVRange range;
1299 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1300 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1301 ASSERT_NE(nullptr, capability);
1302 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1303 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1304 }
1305
1306 /**
1307 * @tc.number : VIDEO_SWDEC_CAP_API_6100
1308 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1309 * @tc.desc : api test
1310 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)1311 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)
1312 {
1313 OH_AVErrCode ret = AV_ERR_OK;
1314 OH_AVRange range;
1315 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1316 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1317 ASSERT_NE(nullptr, capability);
1318 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1319 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1320 }
1321
1322 /**
1323 * @tc.number : VIDEO_SWDEC_CAP_API_6200
1324 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1325 * @tc.desc : api test
1326 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)1327 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)
1328 {
1329 OH_AVErrCode ret = AV_ERR_OK;
1330 OH_AVRange range;
1331 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1332 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1333 ASSERT_NE(nullptr, capability);
1334 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1335 ASSERT_EQ(AV_ERR_OK, ret);
1336 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1337 ASSERT_GE(range.minVal, 0);
1338 ASSERT_GT(range.maxVal, 0);
1339
1340 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1341 ASSERT_EQ(AV_ERR_OK, ret);
1342 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1343 ASSERT_GE(range.minVal, 0);
1344 ASSERT_GT(range.maxVal, 0);
1345 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 3840, 2160, &range);
1346 ASSERT_EQ(AV_ERR_OK, ret);
1347 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1348 ASSERT_GE(range.minVal, 0);
1349 ASSERT_GT(range.maxVal, 0);
1350 }
1351
1352 /**
1353 * @tc.number : VIDEO_SWDEC_CAP_API_6300
1354 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1355 * @tc.desc : api test
1356 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)1357 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)
1358 {
1359 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1360 ASSERT_NE(nullptr, capability);
1361 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1362 }
1363
1364 /**
1365 * @tc.number : VIDEO_SWDEC_CAP_API_6400
1366 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1367 * @tc.desc : api test
1368 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)1369 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)
1370 {
1371 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1372 ASSERT_NE(nullptr, capability);
1373 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1374 }
1375
1376 /**
1377 * @tc.number : VIDEO_SWDEC_CAP_API_6500
1378 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1379 * @tc.desc : api test
1380 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)1381 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)
1382 {
1383 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1384 ASSERT_NE(nullptr, capability);
1385 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1386 }
1387
1388 /**
1389 * @tc.number : VIDEO_SWDEC_CAP_API_6600
1390 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1391 * @tc.desc : api test
1392 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)1393 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)
1394 {
1395 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1396 }
1397
1398 /**
1399 * @tc.number : VIDEO_SWDEC_CAP_API_6700
1400 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1401 * @tc.desc : api test
1402 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)1403 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)
1404 {
1405 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1406 ASSERT_NE(nullptr, capability);
1407 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1408 }
1409
1410 /**
1411 * @tc.number : VIDEO_SWDEC_CAP_API_6800
1412 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1413 * @tc.desc : api test
1414 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)1415 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)
1416 {
1417 OH_AVErrCode ret = AV_ERR_OK;
1418 const int32_t *pixelFormat = nullptr;
1419 uint32_t pixelFormatNum = 0;
1420 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1421 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1422 }
1423
1424 /**
1425 * @tc.number : VIDEO_SWDEC_CAP_API_6900
1426 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1427 * @tc.desc : api test
1428 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)1429 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)
1430 {
1431 OH_AVErrCode ret = AV_ERR_OK;
1432 uint32_t pixelFormatNum = 0;
1433 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1434 ASSERT_NE(nullptr, capability);
1435 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1436 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1437 }
1438
1439 /**
1440 * @tc.number : VIDEO_SWDEC_CAP_API_7000
1441 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1442 * @tc.desc : api test
1443 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)1444 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)
1445 {
1446 OH_AVErrCode ret = AV_ERR_OK;
1447 const int32_t *pixelFormat = nullptr;
1448 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1449 ASSERT_NE(nullptr, capability);
1450 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1451 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1452 }
1453
1454 /**
1455 * @tc.number : VIDEO_SWDEC_CAP_API_7100
1456 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1457 * @tc.desc : api test
1458 */
HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)1459 HWTEST_F(SwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)
1460 {
1461 OH_AVErrCode ret = AV_ERR_OK;
1462 const int32_t *pixelFormat = nullptr;
1463 uint32_t pixelFormatNum = 0;
1464 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
1465 ASSERT_NE(nullptr, capability);
1466 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1467 ASSERT_NE(nullptr, pixelFormat);
1468 ASSERT_EQ(pixelFormatNum, PIXFORMAT_NUM);
1469 ASSERT_EQ(AV_ERR_OK, ret);
1470 for (int i = 0; i < pixelFormatNum; i++) {
1471 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1472 ASSERT_NE(nullptr, vdec_);
1473 format = OH_AVFormat_Create();
1474 ASSERT_NE(nullptr, format);
1475 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1476 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1477 EXPECT_EQ(pixelFormat[i], i == pixelFormatNum - 1 ? i + 2 : i + 1);
1478 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1479 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1480 OH_AVFormat_Destroy(format);
1481 OH_VideoDecoder_Destroy(vdec_);
1482 }
1483 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
1484 ASSERT_NE(nullptr, vdec_);
1485 format = OH_AVFormat_Create();
1486 ASSERT_NE(nullptr, format);
1487 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1488 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1489 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1490 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1491 }
1492 } // namespace