1 /*
2 * Copyright (C) 2025 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_api11_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 H263SwdecApiNdkTest : 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_h263";
62 const string CODEC_NAME = "OH.Media.Codec.Decoder.Video.H263";
63 VDecAPI11Signal *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 H263SwdecApiNdkTest::SetUpTestCase() {}
TearDownTestCase()69 void H263SwdecApiNdkTest::TearDownTestCase() {}
SetUp()70 void H263SwdecApiNdkTest::SetUp()
71 {
72 signal_ = new VDecAPI11Signal();
73 }
TearDown()74 void H263SwdecApiNdkTest::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_H263SWDEC_API_0100
95 * @tc.name : repeat create OH_VideoDecoder_CreateByName
96 * @tc.desc : function test
97 */
98 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0100, TestSize.Level2)
99 {
100 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
101 ASSERT_NE(vdec_, NULL);
102 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
103 ASSERT_NE(vdec_2, NULL);
104 OH_VideoDecoder_Destroy(vdec_2);
105 vdec_2 = nullptr;
106 }
107
108 /**
109 * @tc.number : VIDEO_H263SWDEC_API_0200
110 * @tc.name : create configure configure
111 * @tc.desc : function test
112 */
113 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0200, TestSize.Level2)
114 {
115 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
116 ASSERT_NE(NULL, vdec_);
117
118 OH_AVFormat *format = OH_AVFormat_Create();
119 ASSERT_NE(NULL, format);
120
121 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
122 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
123 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
124
125 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
126 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Configure(vdec_, format));
127 }
128
129 /**
130 * @tc.number : VIDEO_H263SWDEC_API_0300
131 * @tc.name : create configure start start
132 * @tc.desc : function test
133 */
134 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0300, TestSize.Level2)
135 {
136 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
137 ASSERT_NE(NULL, vdec_);
138
139 OH_AVFormat *format = OH_AVFormat_Create();
140 ASSERT_NE(NULL, format);
141
142 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
143 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
144 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
145
146 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
147 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
148 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Start(vdec_));
149 }
150
151 /**
152 * @tc.number : VIDEO_H263SWDEC_API_0400
153 * @tc.name : create configure start stop stop
154 * @tc.desc : function test
155 */
156 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0400, TestSize.Level2)
157 {
158 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
159 ASSERT_NE(NULL, vdec_);
160
161 OH_AVFormat *format = OH_AVFormat_Create();
162 ASSERT_NE(NULL, format);
163
164 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
165 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
166 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
167
168 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
169 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
170 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
171 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
172 }
173
174 /**
175 * @tc.number : VIDEO_H263SWDEC_API_0500
176 * @tc.name : create configure start stop reset reset
177 * @tc.desc : function test
178 */
179 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0500, TestSize.Level2)
180 {
181 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
182 ASSERT_NE(NULL, vdec_);
183
184 OH_AVFormat *format = OH_AVFormat_Create();
185 ASSERT_NE(NULL, format);
186
187 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
188 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
189 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
190
191 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
192 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
193 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
194 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
195 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
196 }
197
198 /**
199 * @tc.number : VIDEO_H263SWDEC_API_0600
200 * @tc.name : create configure start EOS EOS
201 * @tc.desc : function test
202 */
203 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0600, TestSize.Level2)
204 {
205 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
206 ASSERT_NE(NULL, vdec_);
207
208 OH_AVFormat *format = OH_AVFormat_Create();
209 ASSERT_NE(NULL, format);
210
211 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
212 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
213 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
214
215 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
216 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
217
218 OH_AVCodecBufferAttr attr;
219 attr.pts = 0;
220 attr.size = 0;
221 attr.offset = 0;
222 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
223
224 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
225 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
226 }
227
228 /**
229 * @tc.number : VIDEO_H263SWDEC_API_0700
230 * @tc.name : create configure start flush flush
231 * @tc.desc : function test
232 */
233 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0700, TestSize.Level2)
234 {
235 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
236 ASSERT_NE(NULL, vdec_);
237
238 OH_AVFormat *format = OH_AVFormat_Create();
239 ASSERT_NE(NULL, format);
240
241 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
242 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
243 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
244
245 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
246 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
247 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
248 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
249 }
250
251 /**
252 * @tc.number : VIDEO_H263SWDEC_API_0800
253 * @tc.name : create configure start stop release release
254 * @tc.desc : function test
255 */
256 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0800, TestSize.Level2)
257 {
258 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
259 ASSERT_NE(NULL, vdec_);
260
261 OH_AVFormat *format = OH_AVFormat_Create();
262 ASSERT_NE(NULL, format);
263
264 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
265 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
266 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
267
268 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
269 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
270 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
271 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
272 vdec_ = nullptr;
273 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
274 }
275
276 /**
277 * @tc.number : VIDEO_H263SWDEC_API_0900
278 * @tc.name : create create
279 * @tc.desc : function test
280 */
281 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_0900, TestSize.Level2)
282 {
283 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_H263);
284 ASSERT_NE(vdec_, NULL);
285 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_H263);
286 ASSERT_NE(vdec_2, NULL);
287 OH_VideoDecoder_Destroy(vdec_2);
288 vdec_2 = nullptr;
289 }
290
291 /**
292 * @tc.number : VIDEO_H263SWDEC_API_1000
293 * @tc.name : repeat OH_VideoDecoder_RegisterSetCallback
294 * @tc.desc : function test
295 */
296 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_1000, TestSize.Level2)
297 {
298 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
299 OH_AVCodecCallback cb_;
300 cb_.onError = VdecAPI11Error;
301 cb_.onStreamChanged = VdecAPI11FormatChanged;
302 cb_.onNeedInputBuffer = VdecAPI11InputDataReady;
303 cb_.onNewOutputBuffer = VdecAPI11OutputDataReady;
304 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_RegisterCallback(vdec_, cb_, NULL));
305 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_RegisterCallback(vdec_, cb_, NULL));
306 }
307
308 /**
309 * @tc.number : VIDEO_H263SWDEC_API_1100
310 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
311 * @tc.desc : function test
312 */
313 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_1100, TestSize.Level2)
314 {
315 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
316 OH_AVFormat *format = OH_VideoDecoder_GetOutputDescription(vdec_);
317 ASSERT_NE(NULL, format);
318 format = OH_VideoDecoder_GetOutputDescription(vdec_);
319 ASSERT_NE(NULL, format);
320 }
321
322 /**
323 * @tc.number : VIDEO_H263SWDEC_API_1200
324 * @tc.name : repeat OH_VideoDecoder_SetParameter
325 * @tc.desc : function test
326 */
327 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_API_1200, TestSize.Level2)
328 {
329 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
330 ASSERT_NE(NULL, vdec_);
331
332 OH_AVFormat *format = OH_AVFormat_Create();
333 ASSERT_NE(NULL, format);
334
335 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
336 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
337 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
338
339 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
340 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
341 }
342
343 /**
344 * @tc.number : VIDEO_H263SWDEC_CAP_API_0100
345 * @tc.name : OH_AVCodec_GetCapability param correct
346 * @tc.desc : function test
347 */
348 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0100, TestSize.Level1)
349 {
350 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
351 ASSERT_NE(cap, nullptr);
352 ASSERT_FALSE(OH_AVCapability_IsHardware(cap));
353 }
354
355 /**
356 * @tc.number : VIDEO_H263SWDEC_CAP_API_0200
357 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param correct
358 * @tc.desc : function test
359 */
360 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0200, TestSize.Level1)
361 {
362 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
363 ASSERT_NE(cap, nullptr);
364 ASSERT_EQ(64, OH_AVCapability_GetMaxSupportedInstances(cap));
365 }
366
367 /**
368 * @tc.number : VIDEO_H263SWDEC_CAP_API_0300
369 * @tc.name : OH_AVCapability_GetName param correct
370 * @tc.desc : function test
371 */
372 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0300, TestSize.Level1)
373 {
374 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
375 ASSERT_NE(cap, nullptr);
376 ASSERT_EQ(CODEC_NAME, OH_AVCapability_GetName(cap));
377 }
378
379 /**
380 * @tc.number : VIDEO_H263SWDEC_CAP_API_0400
381 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
382 * @tc.desc : api test
383 */
384 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0400, TestSize.Level1)
385 {
386 OH_AVErrCode ret = AV_ERR_OK;
387 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
388 ASSERT_NE(nullptr, capability);
389 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
390 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
391 }
392
393 /**
394 * @tc.number : VIDEO_H263SWDEC_CAP_API_0500
395 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
396 * @tc.desc : api test
397 */
398 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0500, TestSize.Level1)
399 {
400 OH_AVErrCode ret = AV_ERR_OK;
401 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
402 ASSERT_NE(nullptr, capability);
403 int32_t alignment = 0;
404 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
405 cout << "WidthAlignment " << alignment << endl;
406 ASSERT_EQ(AV_ERR_OK, ret);
407 ASSERT_GE(alignment, 0);
408 }
409
410 /**
411 * @tc.number : VIDEO_H263SWDEC_CAP_API_0600
412 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
413 * @tc.desc : api test
414 */
415 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0600, TestSize.Level1)
416 {
417 OH_AVErrCode ret = AV_ERR_OK;
418 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
419 ASSERT_NE(nullptr, capability);
420 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
421 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
422 }
423
424 /**
425 * @tc.number : VIDEO_H263SWDEC_CAP_API_0700
426 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
427 * @tc.desc : api test
428 */
429 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0700, TestSize.Level1)
430 {
431 OH_AVErrCode ret = AV_ERR_OK;
432 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
433 ASSERT_NE(nullptr, capability);
434 int32_t alignment = 0;
435 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
436 cout << "HeightAlignment " << alignment << endl;
437 ASSERT_EQ(AV_ERR_OK, ret);
438 ASSERT_GE(alignment, 0);
439 }
440
441 /**
442 * @tc.number : VIDEO_H263SWDEC_CAP_API_0800
443 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
444 * @tc.desc : api test
445 */
446 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0800, TestSize.Level1)
447 {
448 OH_AVErrCode ret = AV_ERR_OK;
449 OH_AVRange range;
450 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
451 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
452 ASSERT_NE(nullptr, capability);
453 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range);
454 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
455 }
456
457 /**
458 * @tc.number : VIDEO_H263SWDEC_CAP_API_0900
459 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
460 * @tc.desc : api test
461 */
462 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_0900, TestSize.Level1)
463 {
464 OH_AVErrCode ret = AV_ERR_OK;
465 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
466 ASSERT_NE(nullptr, capability);
467 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, nullptr);
468 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
469 }
470
471 /**
472 * @tc.number : VIDEO_H263SWDEC_CAP_API_1000
473 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
474 * @tc.desc : api test
475 */
476 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1000, TestSize.Level1)
477 {
478 OH_AVErrCode ret = AV_ERR_OK;
479 OH_AVRange range;
480 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
481 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
482 ASSERT_NE(nullptr, capability);
483 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
484 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
485 }
486
487 /**
488 * @tc.number : VIDEO_H263SWDEC_CAP_API_1100
489 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
490 * @tc.desc : api test
491 */
492 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1100, TestSize.Level1)
493 {
494 OH_AVErrCode ret = AV_ERR_OK;
495 OH_AVRange range;
496 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
497 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
498 ASSERT_NE(nullptr, capability);
499 const char *codecName = OH_AVCapability_GetName(capability);
500 ASSERT_NE(nullptr, codecName);
501 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
502 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
503 ASSERT_EQ(AV_ERR_OK, ret);
504 ASSERT_EQ(true, (range.minVal >= 0));
505 ASSERT_EQ(true, (range.maxVal > 0));
506 vdec_ = OH_VideoDecoder_CreateByName(codecName);
507 ASSERT_NE(nullptr, vdec_);
508 format = OH_AVFormat_Create();
509 ASSERT_NE(nullptr, format);
510 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
511 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
512 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
513 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
514 OH_VideoDecoder_Destroy(vdec_);
515 vdec_ = OH_VideoDecoder_CreateByName(codecName);
516 ASSERT_NE(nullptr, vdec_);
517 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
518 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
519 }
520
521 /**
522 * @tc.number : VIDEO_H263SWDEC_CAP_API_1200
523 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
524 * @tc.desc : api test
525 */
526 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1200, TestSize.Level1)
527 {
528 OH_AVErrCode ret = AV_ERR_OK;
529 OH_AVRange range;
530 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
531 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
532 ASSERT_NE(nullptr, capability);
533 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
534 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
535 }
536
537 /**
538 * @tc.number : VIDEO_H263SWDEC_CAP_API_1300
539 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
540 * @tc.desc : api test
541 */
542 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1300, TestSize.Level1)
543 {
544 OH_AVErrCode ret = AV_ERR_OK;
545 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
546 ASSERT_NE(nullptr, capability);
547 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
548 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
549 }
550
551 /**
552 * @tc.number : VIDEO_H263SWDEC_CAP_API_1400
553 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
554 * @tc.desc : api test
555 */
556 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1400, TestSize.Level1)
557 {
558 OH_AVErrCode ret = AV_ERR_OK;
559 OH_AVRange range;
560 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
561 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
562 ASSERT_NE(nullptr, capability);
563 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
564 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
565 }
566
567 /**
568 * @tc.number : VIDEO_H263SWDEC_CAP_API_1500
569 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
570 * @tc.desc : api test
571 */
572 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1500, TestSize.Level1)
573 {
574 OH_AVErrCode ret = AV_ERR_OK;
575 OH_AVRange range;
576 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
577 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
578 ASSERT_NE(nullptr, capability);
579 const char *codecName = OH_AVCapability_GetName(capability);
580 ASSERT_NE(nullptr, codecName);
581 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
582 ASSERT_EQ(AV_ERR_OK, ret);
583 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
584 ASSERT_EQ(true, (range.minVal >= 0));
585 ASSERT_EQ(true, (range.maxVal > 0));
586 vdec_ = OH_VideoDecoder_CreateByName(codecName);
587 ASSERT_NE(nullptr, vdec_);
588 format = OH_AVFormat_Create();
589 ASSERT_NE(nullptr, format);
590 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
591 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
592 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
593 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
594 OH_VideoDecoder_Destroy(vdec_);
595 vdec_ = OH_VideoDecoder_CreateByName(codecName);
596 ASSERT_NE(nullptr, vdec_);
597 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
598 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
599 }
600
601 /**
602 * @tc.number : VIDEO_H263SWDEC_CAP_API_1600
603 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
604 * @tc.desc : api test
605 */
606 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1600, TestSize.Level1)
607 {
608 OH_AVErrCode ret = AV_ERR_OK;
609 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
610 ASSERT_NE(nullptr, capability);
611 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
612 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
613 }
614
615 /**
616 * @tc.number : VIDEO_H263SWDEC_CAP_API_1700
617 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
618 * @tc.desc : api test
619 */
620 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1700, TestSize.Level1)
621 {
622 OH_AVErrCode ret = AV_ERR_OK;
623 OH_AVRange range;
624 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
625 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
626 ASSERT_NE(nullptr, capability);
627 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
628 ASSERT_EQ(AV_ERR_OK, ret);
629 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
630 ASSERT_GE(range.minVal, 0);
631 ASSERT_GT(range.maxVal, 0);
632 }
633
634 /**
635 * @tc.number : VIDEO_H263SWDEC_CAP_API_1800
636 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
637 * @tc.desc : api test
638 */
639 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1800, TestSize.Level1)
640 {
641 OH_AVErrCode ret = AV_ERR_OK;
642 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
643 ASSERT_NE(nullptr, capability);
644 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
645 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
646 }
647
648 /**
649 * @tc.number : VIDEO_H263SWDEC_CAP_API_1900
650 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
651 * @tc.desc : api test
652 */
653 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_1900, TestSize.Level1)
654 {
655 OH_AVErrCode ret = AV_ERR_OK;
656 OH_AVRange widthRange;
657 OH_AVRange heightRange;
658 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
659 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
660 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
661 ASSERT_NE(nullptr, capability);
662 const char *codecName = OH_AVCapability_GetName(capability);
663 ASSERT_NE(nullptr, codecName);
664 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
665 ASSERT_EQ(AV_ERR_OK, ret);
666 cout << "minval=" << heightRange.minVal << " maxval=" << heightRange.maxVal << endl;
667 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
668 ASSERT_EQ(AV_ERR_OK, ret);
669 cout << "minval=" << widthRange.minVal << " maxval=" << widthRange.maxVal << endl;
670 vdec_ = OH_VideoDecoder_CreateByName(codecName);
671 ASSERT_NE(nullptr, vdec_);
672 format = OH_AVFormat_Create();
673 ASSERT_NE(nullptr, format);
674 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
675 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.minVal - 1);
676 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
677 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
678 OH_VideoDecoder_Destroy(vdec_);
679 vdec_ = OH_VideoDecoder_CreateByName(codecName);
680 ASSERT_NE(nullptr, vdec_);
681 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, widthRange.maxVal + 1);
682 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
683 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
684 }
685
686 /**
687 * @tc.number : VIDEO_H263SWDEC_CAP_API_2000
688 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
689 * @tc.desc : api test
690 */
691 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2000, TestSize.Level1)
692 {
693 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
694 ASSERT_NE(nullptr, capability);
695 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
696 }
697
698 /**
699 * @tc.number : VIDEO_H263SWDEC_CAP_API_2100
700 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
701 * @tc.desc : api test
702 */
703 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2100, TestSize.Level1)
704 {
705 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
706 ASSERT_NE(nullptr, capability);
707 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
708 }
709
710 /**
711 * @tc.number : VIDEO_H263SWDEC_CAP_API_2200
712 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
713 * @tc.desc : api test
714 */
715 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2200, TestSize.Level1)
716 {
717 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
718 ASSERT_NE(nullptr, capability);
719 OH_AVRange heightRange;
720 OH_AVRange widthRange;
721 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoHeightRange(capability, &heightRange));
722 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoWidthRange(capability, &widthRange));
723 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, widthRange.maxVal + 1, heightRange.maxVal + 1));
724 }
725 /**
726 * @tc.number : VIDEO_H263SWDEC_CAP_API_2300
727 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
728 * @tc.desc : api test
729 */
730 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2300, TestSize.Level1)
731 {
732 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
733 ASSERT_NE(nullptr, capability);
734 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
735 }
736
737 /**
738 * @tc.number : VIDEO_H263SWDEC_CAP_API_2400
739 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
740 * @tc.desc : api test
741 */
742 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2400, TestSize.Level1)
743 {
744 OH_AVErrCode ret = AV_ERR_OK;
745 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
746 ASSERT_NE(nullptr, capability);
747 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
748 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
749 }
750
751 /**
752 * @tc.number : VIDEO_H263SWDEC_CAP_API_2500
753 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
754 * @tc.desc : api test
755 */
756 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2500, TestSize.Level1)
757 {
758 OH_AVErrCode ret = AV_ERR_OK;
759 OH_AVRange range;
760 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
761 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
762 ASSERT_NE(nullptr, capability);
763 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
764 ASSERT_EQ(AV_ERR_OK, ret);
765 ASSERT_GE(range.minVal, 0);
766 ASSERT_GT(range.maxVal, 0);
767 }
768
769 /**
770 * @tc.number : VIDEO_H263SWDEC_CAP_API_2600
771 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
772 * @tc.desc : api test
773 */
774 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2600, TestSize.Level1)
775 {
776 OH_AVErrCode ret = AV_ERR_OK;
777 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
778 ASSERT_NE(nullptr, capability);
779 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
780 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
781 }
782
783 /**
784 * @tc.number : VIDEO_H263SWDEC_CAP_API_2700
785 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
786 * @tc.desc : api test
787 */
788 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2700, TestSize.Level1)
789 {
790 OH_AVErrCode ret = AV_ERR_OK;
791 OH_AVRange range;
792 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
793 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
794 ASSERT_NE(nullptr, capability);
795 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
796 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
797 }
798
799 /**
800 * @tc.number : VIDEO_H263SWDEC_CAP_API_2800
801 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
802 * @tc.desc : api test
803 */
804 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2800, TestSize.Level1)
805 {
806 OH_AVErrCode ret = AV_ERR_OK;
807 OH_AVRange range;
808 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
809 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
810 ASSERT_NE(nullptr, capability);
811 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
812 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
813 }
814
815 /**
816 * @tc.number : VIDEO_H263SWDEC_CAP_API_2900
817 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
818 * @tc.desc : api test
819 */
820 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_2900, TestSize.Level1)
821 {
822 OH_AVErrCode ret = AV_ERR_OK;
823 int32_t width = 1280;
824 int32_t height = 720;
825 OH_AVRange range;
826 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
827 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
828 ASSERT_NE(nullptr, capability);
829 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, width, height, &range);
830 ASSERT_EQ(AV_ERR_OK, ret);
831 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
832 ASSERT_GE(range.minVal, 0);
833 ASSERT_GT(range.maxVal, 0);
834
835 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
836 ASSERT_EQ(AV_ERR_OK, ret);
837 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
838 ASSERT_GE(range.minVal, 0);
839 ASSERT_GT(range.maxVal, 0);
840 width = 2048;
841 height = 1152;
842 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, width, height, &range);
843 ASSERT_EQ(AV_ERR_OK, ret);
844 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
845 ASSERT_GE(range.minVal, 0);
846 ASSERT_GT(range.maxVal, 0);
847 }
848
849 /**
850 * @tc.number : VIDEO_H263SWDEC_CAP_API_3000
851 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
852 * @tc.desc : api test
853 */
854 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3000, TestSize.Level1)
855 {
856 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
857 ASSERT_NE(nullptr, capability);
858 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
859 }
860
861 /**
862 * @tc.number : VIDEO_H263SWDEC_CAP_API_3100
863 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
864 * @tc.desc : api test
865 */
866 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3100, TestSize.Level1)
867 {
868 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
869 ASSERT_NE(nullptr, capability);
870 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
871 }
872
873 /**
874 * @tc.number : VIDEO_H263SWDEC_CAP_API_3200
875 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
876 * @tc.desc : api test
877 */
878 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3200, TestSize.Level1)
879 {
880 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
881 ASSERT_NE(nullptr, capability);
882 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
883 }
884
885 /**
886 * @tc.number : VIDEO_H263SWDEC_CAP_API_3300
887 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
888 * @tc.desc : api test
889 */
890 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3300, TestSize.Level1)
891 {
892 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
893 ASSERT_NE(nullptr, capability);
894 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
895 }
896
897 /**
898 * @tc.number : VIDEO_H263SWDEC_CAP_API_3400
899 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
900 * @tc.desc : api test
901 */
902 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3400, TestSize.Level1)
903 {
904 OH_AVErrCode ret = AV_ERR_OK;
905 uint32_t pixelFormatNum = 0;
906 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
907 ASSERT_NE(nullptr, capability);
908 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
909 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
910 }
911
912 /**
913 * @tc.number : VIDEO_H263SWDEC_CAP_API_3500
914 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
915 * @tc.desc : api test
916 */
917 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3500, TestSize.Level1)
918 {
919 OH_AVErrCode ret = AV_ERR_OK;
920 const int32_t *pixelFormat = nullptr;
921 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
922 ASSERT_NE(nullptr, capability);
923 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
924 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
925 }
926
927 /**
928 * @tc.number : VIDEO_H263SWDEC_CAP_API_3600
929 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
930 * @tc.desc : api test
931 */
932 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3600, TestSize.Level1)
933 {
934 OH_AVErrCode ret = AV_ERR_OK;
935 const int32_t *pixelFormat = nullptr;
936 uint32_t pixelFormatNum = 0;
937 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
938 ASSERT_NE(nullptr, capability);
939 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
940 ASSERT_NE(nullptr, pixelFormat);
941 ASSERT_EQ(pixelFormatNum, PIXFORMAT_NUM);
942 ASSERT_EQ(AV_ERR_OK, ret);
943 for (int i = 0; i < pixelFormatNum; i++) {
944 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
945 ASSERT_NE(nullptr, vdec_);
946 format = OH_AVFormat_Create();
947 ASSERT_NE(nullptr, format);
948 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
949 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
950 EXPECT_EQ(pixelFormat[i], i == pixelFormatNum - 1 ? i + 2 : i + 1);
951 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
952 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
953 OH_AVFormat_Destroy(format);
954 OH_VideoDecoder_Destroy(vdec_);
955 }
956 vdec_ = OH_VideoDecoder_CreateByName(CODEC_NAME.c_str());
957 ASSERT_NE(nullptr, vdec_);
958 format = OH_AVFormat_Create();
959 ASSERT_NE(nullptr, format);
960 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
961 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
962 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
963 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
964 }
965
966 /**
967 * @tc.number : VIDEO_H263SWDEC_CAP_API_3700
968 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
969 * @tc.desc : api test
970 */
971 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3700, TestSize.Level1)
972 {
973 OH_AVErrCode ret = AV_ERR_OK;
974 const int32_t *profiles = nullptr;
975 uint32_t profileNum = 0;
976 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
977 ASSERT_NE(nullptr, capability);
978 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
979 ASSERT_EQ(AV_ERR_OK, ret);
980 ASSERT_GT(profileNum, 0);
981 ASSERT_NE(nullptr, profiles);
982 for (int i = 0; i < profileNum; i++) {
983 EXPECT_GE(profiles[i], 0);
984 }
985 }
986
987 /**
988 * @tc.number : VIDEO_H263SWDEC_CAP_API_3800
989 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
990 * @tc.desc : api test
991 */
992 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3800, TestSize.Level1)
993 {
994 OH_AVErrCode ret = AV_ERR_OK;
995 const int32_t *levels = nullptr;
996 uint32_t levelNum = 0;
997 const int32_t *profiles = nullptr;
998 uint32_t profileNum = 0;
999 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
1000 ASSERT_NE(nullptr, capability);
1001 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1002 ASSERT_EQ(AV_ERR_OK, ret);
1003 ASSERT_GT(profileNum, 0);
1004 ASSERT_NE(nullptr, profiles);
1005 for (int i = 0; i < profileNum; i++) {
1006 EXPECT_GE(profiles[i], 0);
1007 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, profiles[i], &levels, &levelNum);
1008 ASSERT_EQ(AV_ERR_OK, ret);
1009 ASSERT_NE(nullptr, levels);
1010 EXPECT_GT(levelNum, 0);
1011 for (int j = 0; j < levelNum; j++) {
1012 EXPECT_GE(levels[j], 0);
1013 }
1014 }
1015 }
1016
1017 /**
1018 * @tc.number : VIDEO_H263SWDEC_CAP_API_3900
1019 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1020 * @tc.desc : api test
1021 */
1022 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_3900, TestSize.Level1)
1023 {
1024 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
1025 ASSERT_NE(nullptr, capability);
1026 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
1027 }
1028
1029 /**
1030 * @tc.number : VIDEO_MPEG2SWDEC_CAP_4000
1031 * @tc.name : OH_AVCapability_IsFeatureSupported param error
1032 * @tc.desc : api test
1033 */
1034
1035 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_4000, TestSize.Level1)
1036 {
1037 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
1038 ASSERT_NE(nullptr, capability);
1039 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_LOW_LATENCY));
1040 }
1041
1042 /**
1043 * @tc.number : VIDEO_MPEG2SWDEC_CAP_4100
1044 * @tc.name : OH_AVCapability_GetFeatureProperties param error
1045 * @tc.desc : api test
1046 */
1047 HWTEST_F(H263SwdecApiNdkTest, VIDEO_H263SWDEC_CAP_API_4100, TestSize.Level1)
1048 {
1049 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_H263, false, SOFTWARE);
1050 ASSERT_NE(nullptr, capability);
1051 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(capability, VIDEO_LOW_LATENCY);
1052 ASSERT_EQ(nullptr, format);
1053 OH_AVFormat_Destroy(format);
1054 }
1055 } // namespace