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 #include <atomic>
19 #include <fstream>
20 #include <thread>
21 #include <mutex>
22 #include <queue>
23 #include <string>
24
25 #include "gtest/gtest.h"
26 #include "videodec_sample.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 using namespace std;
35 using namespace OHOS;
36 using namespace OHOS::Media;
37 using namespace testing::ext;
38 namespace OHOS {
39 namespace Media {
40 class HevcSwdecApiNdkTest : public testing::Test {
41 public:
42 // SetUpTestCase: Called before all test cases
43 static void SetUpTestCase(void);
44 // TearDownTestCase: Called after all test case
45 static void TearDownTestCase(void);
46 // SetUp: Called before each test cases
47 void SetUp(void);
48 // TearDown: Called after each test cases
49 void TearDown(void);
50 };
51
52 namespace {
53 OH_AVErrCode ret_1 = AV_ERR_OK;
54 uint32_t pixelFormatNum_1 = 0;
55 const int32_t *pixelFormat_1 = nullptr;
56 OH_AVCodec *vdec_ = NULL;
57 OH_AVCapability *cap = nullptr;
58 OH_AVCapability *cap_hevc = nullptr;
59 VDecSignal *signal_;
60 const string INVALID_CODEC_NAME = "avdec_h265";
61 const string VIDEO_DECODER_HEVC_NAME = "OH.Media.Codec.Decoder.Video.HEVC";
62 const string VIDEO_DECODER_HISI = "OMX.hisi.video.decoder.hevc";
63 static string g_codecName_hevc = "";
64 OH_AVFormat *format;
65 constexpr uint32_t DEFAULT_WIDTH = 1920;
66 constexpr uint32_t DEFAULT_HEIGHT = 1080;
67 constexpr double DEFAULT_FRAME_RATE = 30.0;
68 } // namespace
69
SetUpTestCase()70 void HevcSwdecApiNdkTest::SetUpTestCase()
71 {
72 cap_hevc = OH_AVCodec_GetCapabilityByCategory(
73 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
74 g_codecName_hevc = OH_AVCapability_GetName(cap_hevc);
75 cout << "g_codecName_hevc: " << g_codecName_hevc << endl;
76 }
TearDownTestCase()77 void HevcSwdecApiNdkTest::TearDownTestCase() {}
SetUp()78 void HevcSwdecApiNdkTest::SetUp()
79 {
80 signal_ = new VDecSignal();
81 }
TearDown()82 void HevcSwdecApiNdkTest::TearDown()
83 {
84 if (format != nullptr) {
85 OH_AVFormat_Destroy(format);
86 format = nullptr;
87 }
88 if (signal_) {
89 delete signal_;
90 signal_ = nullptr;
91 }
92 if (vdec_ != NULL) {
93 OH_VideoDecoder_Destroy(vdec_);
94 vdec_ = nullptr;
95 }
96 }
97 } // namespace Media
98 } // namespace OHOS
99
100 namespace {
101 /**
102 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0100
103 * @tc.name : OH_VideoDecoder_CreateByName para error
104 * @tc.desc : api test
105 */
106 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0100, TestSize.Level2)
107 {
108 if (!access("/system/lib64/media/", 0)) {
109 vdec_ = OH_VideoDecoder_CreateByName(NULL);
110 ASSERT_EQ(NULL, vdec_);
111 }
112 }
113
114 /**
115 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0200
116 * @tc.name : blue zone create decoder fail
117 * @tc.desc : api test
118 */
119 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0200, TestSize.Level2)
120 {
121 if (access("/system/lib64/media/", 0)) {
122 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
123 ASSERT_EQ(NULL, vdec_);
124 }
125 }
126
127 /**
128 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3300
129 * @tc.name : OH_VideoDecoder_SetCallback para error
130 * @tc.desc : api test
131 */
132 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3300, TestSize.Level2)
133 {
134 if (!access("/system/lib64/media/", 0)) {
135 OH_AVCodecAsyncCallback cb_;
136 cb_.onError = VdecError;
137 cb_.onStreamChanged = VdecFormatChanged;
138 cb_.onNeedInputData = VdecInputDataReady;
139 cb_.onNeedOutputData = VdecOutputDataReady;
140 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
141 }
142 }
143
144 /**
145 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1800
146 * @tc.name : OH_VideoDecoder_SetCallback para error
147 * @tc.desc : api test
148 */
149 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1800, TestSize.Level2)
150 {
151 if (!access("/system/lib64/media/", 0)) {
152 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
153 ASSERT_NE(NULL, vdec_);
154
155 OH_AVCodecAsyncCallback cb2_;
156 cb2_.onError = NULL;
157 cb2_.onStreamChanged = NULL;
158 cb2_.onNeedInputData = NULL;
159 cb2_.onNeedOutputData = NULL;
160 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb2_, static_cast<void *>(signal_)));
161 }
162 }
163
164 /**
165 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0300
166 * @tc.name : OH_VideoDecoder_SetCallback para error
167 * @tc.desc : api test
168 */
169 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0300, TestSize.Level2)
170 {
171 if (!access("/system/lib64/media/", 0)) {
172 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
173 OH_AVCodecAsyncCallback cb_;
174 cb_.onError = VdecError;
175 cb_.onStreamChanged = VdecFormatChanged;
176 cb_.onNeedInputData = VdecInputDataReady;
177 cb_.onNeedOutputData = VdecOutputDataReady;
178 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
179 }
180 }
181
182 /**
183 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0400
184 * @tc.name : OH_VideoDecoder_Destroy para error
185 * @tc.desc : api test
186 */
187 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0400, TestSize.Level2)
188 {
189 if (!access("/system/lib64/media/", 0)) {
190 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(NULL));
191 }
192 }
193
194 /**
195 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0500
196 * @tc.name : OH_VideoDecoder_Configure para error
197 * @tc.desc : api test
198 */
199 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0500, TestSize.Level2)
200 {
201 if (!access("/system/lib64/media/", 0)) {
202 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
203 ASSERT_NE(NULL, vdec_);
204 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, NULL));
205 }
206 }
207
208 /**
209 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1400
210 * @tc.name : OH_VideoDecoder_Configure para error
211 * @tc.desc : api test
212 */
213 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1400, TestSize.Level2)
214 {
215 if (!access("/system/lib64/media/", 0)) {
216 format = OH_AVFormat_Create();
217 ASSERT_NE(NULL, format);
218 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
219 }
220 }
221
222 /**
223 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_5000
224 * @tc.name : OH_VideoDecoder_Configure para error
225 * @tc.desc : api test
226 */
227 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5000, TestSize.Level2)
228 {
229 if (!access("/system/lib64/media/", 0)) {
230 format = OH_AVFormat_Create();
231 ASSERT_NE(NULL, format);
232 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
233 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
234 }
235 }
236
237 /**
238 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_5100
239 * @tc.name : OH_VideoDecoder_Configure para error
240 * @tc.desc : api test
241 */
242 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_5100, TestSize.Level2)
243 {
244 if (!access("/system/lib64/media/", 0)) {
245 format = OH_AVFormat_Create();
246 ASSERT_NE(NULL, format);
247 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
248 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
249 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
250 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
251 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
252 }
253 }
254
255 /**
256 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0600
257 * @tc.name : OH_VideoDecoder_Start para error
258 * @tc.desc : api test
259 */
260 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0600, TestSize.Level2)
261 {
262 if (!access("/system/lib64/media/", 0)) {
263 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Start(NULL));
264 }
265 }
266
267 /**
268 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0700
269 * @tc.name : OH_VideoDecoder_Stop para error
270 * @tc.desc : api test
271 */
272 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0700, TestSize.Level2)
273 {
274 if (!access("/system/lib64/media/", 0)) {
275 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Stop(NULL));
276 }
277 }
278
279 /**
280 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0800
281 * @tc.name : OH_VideoDecoder_Flush para error
282 * @tc.desc : api test
283 */
284 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0800, TestSize.Level2)
285 {
286 if (!access("/system/lib64/media/", 0)) {
287 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Flush(NULL));
288 }
289 }
290
291 /**
292 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_0900
293 * @tc.name : OH_VideoDecoder_Reset para error
294 * @tc.desc : api test
295 */
296 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_0900, TestSize.Level2)
297 {
298 if (!access("/system/lib64/media/", 0)) {
299 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Reset(NULL));
300 }
301 }
302
303 /**
304 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1000
305 * @tc.name : OH_VideoDecoder_GetOutputDescription para error
306 * @tc.desc : api test
307 */
308 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1000, TestSize.Level2)
309 {
310 if (!access("/system/lib64/media/", 0)) {
311 ASSERT_EQ(NULL, OH_VideoDecoder_GetOutputDescription(NULL));
312 }
313 }
314
315 /**
316 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1100
317 * @tc.name : OH_VideoDecoder_SetParameter para error
318 * @tc.desc : api test
319 */
320 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1100, TestSize.Level2)
321 {
322 if (!access("/system/lib64/media/", 0)) {
323 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
324 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(vdec_, NULL));
325 }
326 }
327
328 /**
329 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_4100
330 * @tc.name : OH_VideoDecoder_Prepare para error
331 * @tc.desc : api test
332 */
333 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_4100, TestSize.Level2)
334 {
335 if (!access("/system/lib64/media/", 0)) {
336 OH_AVErrCode ret = AV_ERR_OK;
337 ret = OH_VideoDecoder_Prepare(nullptr);
338 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
339 }
340 }
341
342 /**
343 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1500
344 * @tc.name : OH_VideoDecoder_SetParameter para error
345 * @tc.desc : api test
346 */
347 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1500, TestSize.Level2)
348 {
349 if (!access("/system/lib64/media/", 0)) {
350 format = OH_AVFormat_Create();
351 ASSERT_NE(NULL, format);
352 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
353 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
354 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
355 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
356 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(NULL, format));
357 }
358 }
359
360 /**
361 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1200
362 * @tc.name : OH_VideoDecoder_SetSurface para error
363 * @tc.desc : api test
364 */
365 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1200, TestSize.Level2)
366 {
367 if (!access("/system/lib64/media/", 0)) {
368 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
369 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetSurface(vdec_, NULL));
370 }
371 }
372
373 /**
374 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1300
375 * @tc.name : OH_VideoDecoder_CreateByName para correct
376 * @tc.desc : api test
377 */
378 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1300, TestSize.Level2)
379 {
380 if (!access("/system/lib64/media/", 0)) {
381 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
382 ASSERT_NE(NULL, vdec_);
383 }
384 }
385
386 /**
387 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1600
388 * @tc.name : OH_VideoDecoder_CreateByName para error
389 * @tc.desc : api test
390 */
391 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1600, TestSize.Level2)
392 {
393 if (!access("/system/lib64/media/", 0)) {
394 vdec_ = OH_VideoDecoder_CreateByName(INVALID_CODEC_NAME.c_str());
395 ASSERT_EQ(NULL, vdec_);
396 }
397 }
398
399 /**
400 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_1700
401 * @tc.name : OH_VideoDecoder_CreateByName para error
402 * @tc.desc : api test
403 */
404 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_1700, TestSize.Level2)
405 {
406 if (!access("/system/lib64/media/", 0)) {
407 vdec_ = OH_VideoDecoder_CreateByName(INVALID_CODEC_NAME.c_str());
408 ASSERT_EQ(NULL, vdec_);
409 }
410 }
411
412 /**
413 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2200
414 * @tc.name : OH_VideoDecoder_IsValid para error
415 * @tc.desc : api test
416 */
417 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2200, TestSize.Level2)
418 {
419 if (!access("/system/lib64/media/", 0)) {
420 bool isValid = false;
421 OH_AVErrCode ret = AV_ERR_OK;
422 ret = OH_VideoDecoder_IsValid(nullptr, &isValid);
423 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
424 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
425 ASSERT_NE(NULL, vdec_);
426 ret = OH_VideoDecoder_IsValid(vdec_, nullptr);
427 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
428 }
429 }
430
431 /**
432 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2500
433 * @tc.name : OH_VideoDecoder_RenderOutputData para error
434 * @tc.desc : api test
435 */
436 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2500, TestSize.Level2)
437 {
438 if (!access("/system/lib64/media/", 0)) {
439 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_RenderOutputData(NULL, 0));
440 }
441 }
442
443 /**
444 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2600
445 * @tc.name : OH_VideoDecoder_RenderOutputData para error
446 * @tc.desc : api test
447 */
448 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2600, TestSize.Level2)
449 {
450 if (!access("/system/lib64/media/", 0)) {
451 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
452 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_RenderOutputData(vdec_, 0));
453 }
454 }
455
456 /**
457 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2700
458 * @tc.name : OH_VideoDecoder_FreeOutputData para error
459 * @tc.desc : api test
460 */
461 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2700, TestSize.Level2)
462 {
463 if (!access("/system/lib64/media/", 0)) {
464 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_FreeOutputData(NULL, 0));
465 }
466 }
467
468 /**
469 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2800
470 * @tc.name : OH_VideoDecoder_FreeOutputData para error
471 * @tc.desc : api test
472 */
473 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2800, TestSize.Level2)
474 {
475 if (!access("/system/lib64/media/", 0)) {
476 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
477 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, 0));
478 }
479 }
480
481 /**
482 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_2900
483 * @tc.name : OH_VideoDecoder_FreeOutputData para error
484 * @tc.desc : api test
485 */
486 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_2900, TestSize.Level2)
487 {
488 if (!access("/system/lib64/media/", 0)) {
489 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
490 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, -1));
491 }
492 }
493
494 /**
495 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3000
496 * @tc.name : OH_VideoDecoder_PushInputData para error
497 * @tc.desc : api test
498 */
499 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3000, TestSize.Level2)
500 {
501 if (!access("/system/lib64/media/", 0)) {
502 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
503 OH_AVCodecBufferAttr attr;
504 attr.pts = -1;
505 attr.size = -1;
506 attr.offset = -1;
507 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
508 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
509 }
510 }
511
512 /**
513 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3100
514 * @tc.name : OH_VideoDecoder_PushInputData para error
515 * @tc.desc : api test
516 */
517 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3100, TestSize.Level2)
518 {
519 if (!access("/system/lib64/media/", 0)) {
520 OH_AVCodecBufferAttr attr;
521 attr.pts = 0;
522 attr.size = 0;
523 attr.offset = 0;
524 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
525
526 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, -1, attr));
527 }
528 }
529
530 /**
531 * @tc.number : VIDEO_SWDEC_ILLEGAL_PARA_3200
532 * @tc.name : OH_VideoDecoder_PushInputData para error
533 * @tc.desc : api test
534 */
535 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_ILLEGAL_PARA_3200, TestSize.Level2)
536 {
537 if (!access("/system/lib64/media/", 0)) {
538 OH_AVCodecBufferAttr attr;
539 attr.pts = 0;
540 attr.size = 0;
541 attr.offset = 0;
542 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
543 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, 0, attr));
544 }
545 }
546
547 /**
548 * @tc.number : VIDEO_SWDEC_API_0100
549 * @tc.name : OH_VideoDecoder_CreateByName Creat Success and reset
550 * @tc.desc : api test
551 */
552 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0100, TestSize.Level2)
553 {
554 if (!access("/system/lib64/media/", 0)) {
555 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
556 ASSERT_NE(vdec_, NULL);
557 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
558 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
559 vdec_ = nullptr;
560 }
561 }
562
563 /**
564 * @tc.number : VIDEO_SWDEC_API_0200
565 * @tc.name : OH_AVFormat_SetIntValue Setting Properties
566 * @tc.desc : api test
567 */
568 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0200, TestSize.Level2)
569 {
570 if (!access("/system/lib64/media/", 0)) {
571 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
572 ASSERT_NE(NULL, vdec_);
573 format = OH_AVFormat_Create();
574 ASSERT_NE(NULL, format);
575 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
576 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
577 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
578 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
579 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
580 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Configure(vdec_, format));
581 }
582 }
583
584 /**
585 * @tc.number : VIDEO_SWDEC_API_0300
586 * @tc.name : OH_VideoDecoder_Start start decoder
587 * @tc.desc : api test
588 */
589 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0300, TestSize.Level2)
590 {
591 if (!access("/system/lib64/media/", 0)) {
592 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
593 ASSERT_NE(NULL, vdec_);
594 format = OH_AVFormat_Create();
595 ASSERT_NE(NULL, format);
596 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
597 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
598 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
599 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
600 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
601 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
602 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Start(vdec_));
603 }
604 }
605
606 /**
607 * @tc.number : VIDEO_SWDEC_API_0400
608 * @tc.name : OH_VideoDecoder_Stop Stop decoding
609 * @tc.desc : api test
610 */
611 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0400, TestSize.Level2)
612 {
613 if (!access("/system/lib64/media/", 0)) {
614 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
615 ASSERT_NE(NULL, vdec_);
616 format = OH_AVFormat_Create();
617 ASSERT_NE(NULL, format);
618 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
619 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
620 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
621 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
622 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
623 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
624 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
625 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
626 }
627 }
628
629 /**
630 * @tc.number : VIDEO_SWDEC_API_0500
631 * @tc.name : create configure start stop reset reset
632 * @tc.desc : api test
633 */
634 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0500, TestSize.Level2)
635 {
636 if (!access("/system/lib64/media/", 0)) {
637 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
638 ASSERT_NE(NULL, vdec_);
639
640 format = OH_AVFormat_Create();
641 ASSERT_NE(NULL, format);
642
643 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
644 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
645 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
646 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, 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_Stop(vdec_));
651 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
652 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
653 }
654 }
655
656 /**
657 * @tc.number : VIDEO_SWDEC_API_0700
658 * @tc.name : create configure start flush flush
659 * @tc.desc : api test
660 */
661 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0700, TestSize.Level2)
662 {
663 if (!access("/system/lib64/media/", 0)) {
664 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
665 ASSERT_NE(NULL, vdec_);
666 format = OH_AVFormat_Create();
667 ASSERT_NE(NULL, format);
668 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
669 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
670 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
671 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
672 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
673 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
674 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
675 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
676 }
677 }
678
679 /**
680 * @tc.number : VIDEO_SWDEC_API_0800
681 * @tc.name : create configure start stop release release
682 * @tc.desc : api test
683 */
684 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0800, TestSize.Level2)
685 {
686 if (!access("/system/lib64/media/", 0)) {
687 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
688 ASSERT_NE(NULL, vdec_);
689 format = OH_AVFormat_Create();
690 ASSERT_NE(NULL, format);
691 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
692 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
693 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
694 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
695 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
696 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
697 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
698 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
699 vdec_ = nullptr;
700 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
701 }
702 }
703
704 /**
705 * @tc.number : VIDEO_SWDEC_API_0900
706 * @tc.name : create two decoder
707 * @tc.desc : api test
708 */
709 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_0900, TestSize.Level2)
710 {
711 if (!access("/system/lib64/media/", 0)) {
712 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
713 ASSERT_NE(vdec_, NULL);
714 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
715 ASSERT_NE(vdec_2, NULL);
716 OH_VideoDecoder_Destroy(vdec_2);
717 vdec_2 = nullptr;
718 }
719 }
720
721 /**
722 * @tc.number : VIDEO_SWDEC_API_1000
723 * @tc.name : repeat OH_VideoDecoder_SetCallback
724 * @tc.desc : api test
725 */
726 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_1000, TestSize.Level2)
727 {
728 if (!access("/system/lib64/media/", 0)) {
729 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
730 OH_AVCodecAsyncCallback cb_;
731 cb_.onError = VdecError;
732 cb_.onStreamChanged = VdecFormatChanged;
733 cb_.onNeedInputData = VdecInputDataReady;
734 cb_.onNeedOutputData = VdecOutputDataReady;
735 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
736 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
737 }
738 }
739
740 /**
741 * @tc.number : VIDEO_SWDEC_API_1100
742 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
743 * @tc.desc : api test
744 */
745 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_1100, TestSize.Level2)
746 {
747 if (!access("/system/lib64/media/", 0)) {
748 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
749 format = OH_VideoDecoder_GetOutputDescription(vdec_);
750 ASSERT_NE(NULL, format);
751 format = OH_VideoDecoder_GetOutputDescription(vdec_);
752 ASSERT_NE(NULL, format);
753 }
754 }
755
756 /**
757 * @tc.number : VIDEO_SWDEC_API_1200
758 * @tc.name : repeat OH_VideoDecoder_SetParameter
759 * @tc.desc : api test
760 */
761 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_API_1200, TestSize.Level2)
762 {
763 if (!access("/system/lib64/media/", 0)) {
764 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
765 ASSERT_NE(NULL, vdec_);
766 format = OH_AVFormat_Create();
767 ASSERT_NE(NULL, format);
768 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
769 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
770 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
771 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
772 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
773 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
774 }
775 }
776
777 /**
778 * @tc.number : VIDEO_SWDEC_CAP_API_0100
779 * @tc.name : OH_AVCodec_GetCapability
780 * @tc.desc : api test
781 */
782 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0100, TestSize.Level2)
783 {
784 if (!access("/system/lib64/media/", 0)) {
785 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false);
786 ASSERT_NE(cap, nullptr);
787 }
788 }
789
790 /**
791 * @tc.number : VIDEO_SWDEC_CAP_API_0110
792 * @tc.name : OH_AVCodec_GetCapability
793 * @tc.desc : api test
794 */
795 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0110, TestSize.Level2)
796 {
797 if (!access("/system/lib64/media/", 0)) {
798 cap = OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false);
799 string codec_name = OH_AVCapability_GetName(cap);
800 ASSERT_EQ(VIDEO_DECODER_HISI, codec_name);
801 }
802 }
803
804 /**
805 * @tc.number : VIDEO_SWDEC_CAP_API_0200
806 * @tc.name : OH_AVCodec_GetCapability
807 * @tc.desc : api test
808 */
809 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0200, TestSize.Level2)
810 {
811 if (!access("/system/lib64/media/", 0)) {
812 cap = OH_AVCodec_GetCapability(nullptr, false);
813 ASSERT_EQ(cap, nullptr);
814 }
815 }
816
817 /**
818 * @tc.number : VIDEO_SWDEC_CAP_API_0300
819 * @tc.name : OH_AVCodec_GetCapability
820 * @tc.desc : api test
821 */
822 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0300, TestSize.Level2)
823 {
824 if (!access("/system/lib64/media/", 0)) {
825 cap = OH_AVCodec_GetCapabilityByCategory(
826 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
827 string codec_name = OH_AVCapability_GetName(cap);
828 ASSERT_EQ(VIDEO_DECODER_HEVC_NAME, codec_name);
829 }
830 }
831
832 /**
833 * @tc.number : VIDEO_SWDEC_CAP_API_0400
834 * @tc.name : OH_AVCodec_GetCapability
835 * @tc.desc : api test
836 */
837 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0400, TestSize.Level2)
838 {
839 if (!access("/system/lib64/media/", 0)) {
840 cap = OH_AVCodec_GetCapabilityByCategory(nullptr, false, SOFTWARE);
841 ASSERT_EQ(cap, nullptr);
842 }
843 }
844
845 /**
846 * @tc.number : VIDEO_SWDEC_CAP_API_0500
847 * @tc.name : OH_AVCodec_GetCapability
848 * @tc.desc : api test
849 */
850 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0500, TestSize.Level2)
851 {
852 if (!access("/system/lib64/media/", 0)) {
853 cap = OH_AVCodec_GetCapabilityByCategory(
854 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
855 ASSERT_NE(cap, nullptr);
856 ASSERT_FALSE(OH_AVCapability_IsHardware(cap));
857 }
858 }
859
860 /**
861 * @tc.number : VIDEO_SWDEC_CAP_API_0510
862 * @tc.name : OH_AVCodec_GetCapability hevc
863 * @tc.desc : api test
864 */
865 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0510, TestSize.Level2)
866 {
867 if (!access("/system/lib64/media/", 0)) {
868 cap = OH_AVCodec_GetCapabilityByCategory(
869 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
870 ASSERT_NE(cap, nullptr);
871 ASSERT_FALSE(OH_AVCapability_IsHardware(cap));
872 }
873 }
874
875 /**
876 * @tc.number : VIDEO_SWDEC_CAP_API_0600
877 * @tc.name : OH_AVCodec_GetCapability
878 * @tc.desc : api test
879 */
880 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0600, TestSize.Level2)
881 {
882 if (!access("/system/lib64/media/", 0)) {
883 ASSERT_FALSE(OH_AVCapability_IsHardware(nullptr));
884 }
885 }
886
887 /**
888 * @tc.number : VIDEO_SWDEC_CAP_API_0700
889 * @tc.name : OH_AVCodec_GetCapability
890 * @tc.desc : api test
891 */
892 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0700, TestSize.Level2)
893 {
894 if (!access("/system/lib64/media/", 0)) {
895 ASSERT_EQ(0, OH_AVCapability_GetMaxSupportedInstances(nullptr));
896 }
897 }
898
899 /**
900 * @tc.number : VIDEO_SWDEC_CAP_API_0800
901 * @tc.name : OH_AVCodec_GetCapability
902 * @tc.desc : api test
903 */
904 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0800, TestSize.Level2)
905 {
906 if (!access("/system/lib64/media/", 0)) {
907 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
908 ASSERT_NE(cap, nullptr);
909 string codec_name = OH_AVCapability_GetName(cap);
910 ASSERT_EQ(64, OH_AVCapability_GetMaxSupportedInstances(cap));
911 }
912 }
913
914 /**
915 * @tc.number : VIDEO_SWDEC_CAP_API_0900
916 * @tc.name : OH_AVCodec_GetCapability
917 * @tc.desc : api test
918 */
919 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_0900, TestSize.Level2)
920 {
921 if (!access("/system/lib64/media/", 0)) {
922 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
923 ASSERT_NE(cap, nullptr);
924 ASSERT_EQ(VIDEO_DECODER_HEVC_NAME, OH_AVCapability_GetName(cap));
925 }
926 }
927
928 /**
929 * @tc.number : VIDEO_SWDEC_CAP_API_1000
930 * @tc.name : OH_AVCodec_GetCapability
931 * @tc.desc : api test
932 */
933 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1000, TestSize.Level2)
934 {
935 if (!access("/system/lib64/media/", 0)) {
936 const char *name = OH_AVCapability_GetName(nullptr);
937 ASSERT_NE(name, nullptr);
938 ASSERT_EQ(strlen(name), 0);
939 }
940 }
941
942 /**
943 * @tc.number : VIDEO_SWDEC_CAP_API_3100
944 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
945 * @tc.desc : api test
946 */
947 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3100, TestSize.Level2)
948 {
949 if (!access("/system/lib64/media/", 0)) {
950 OH_AVErrCode ret = AV_ERR_OK;
951 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
952 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
953 ASSERT_NE(nullptr, capability);
954 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
955 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
956 }
957 }
958
959 /**
960 * @tc.number : VIDEO_SWDEC_CAP_API_3200
961 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
962 * @tc.desc : api test
963 */
964 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3200, TestSize.Level2)
965 {
966 if (!access("/system/lib64/media/", 0)) {
967 OH_AVErrCode ret = AV_ERR_OK;
968 int32_t alignment = 0;
969 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
970 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
971 }
972 }
973
974 /**
975 * @tc.number : VIDEO_SWDEC_CAP_API_3300
976 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
977 * @tc.desc : api test
978 */
979 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3300, TestSize.Level2)
980 {
981 if (!access("/system/lib64/media/", 0)) {
982 OH_AVErrCode ret = AV_ERR_OK;
983 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
984 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
985 ASSERT_NE(nullptr, capability);
986 int32_t alignment = 0;
987 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
988 ASSERT_EQ(AV_ERR_OK, ret);
989 ASSERT_GE(alignment, 0);
990 ASSERT_EQ(alignment, 2);
991 }
992 }
993 /**
994 * @tc.number : VIDEO_SWDEC_CAP_API_3310
995 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
996 * @tc.desc : api test
997 */
998 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3310, TestSize.Level2)
999 {
1000 if (!access("/system/lib64/media/", 0)) {
1001 OH_AVErrCode ret = AV_ERR_OK;
1002 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1003 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1004 ASSERT_NE(nullptr, capability);
1005 int32_t alignment = 0;
1006 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
1007 ASSERT_EQ(AV_ERR_OK, ret);
1008 ASSERT_GE(alignment, 0);
1009 }
1010 }
1011
1012 /**
1013 * @tc.number : VIDEO_SWDEC_CAP_API_3400
1014 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1015 * @tc.desc : api test
1016 */
1017 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3400, TestSize.Level2)
1018 {
1019 if (!access("/system/lib64/media/", 0)) {
1020 OH_AVErrCode ret = AV_ERR_OK;
1021 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1022 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1023 ASSERT_NE(nullptr, capability);
1024 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
1025 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1026 }
1027 }
1028
1029 /**
1030 * @tc.number : VIDEO_SWDEC_CAP_API_3500
1031 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1032 * @tc.desc : api test
1033 */
1034 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3500, TestSize.Level2)
1035 {
1036 if (!access("/system/lib64/media/", 0)) {
1037 OH_AVErrCode ret = AV_ERR_OK;
1038 int32_t alignment = 0;
1039 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
1040 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1041 }
1042 }
1043
1044 /**
1045 * @tc.number : VIDEO_SWDEC_CAP_API_3600
1046 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
1047 * @tc.desc : api test
1048 */
1049 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3600, TestSize.Level2)
1050 {
1051 if (!access("/system/lib64/media/", 0)) {
1052 OH_AVErrCode ret = AV_ERR_OK;
1053 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1054 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1055 ASSERT_NE(nullptr, capability);
1056 int32_t alignment = 0;
1057 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
1058 ASSERT_EQ(AV_ERR_OK, ret);
1059 ASSERT_GE(alignment, 0);
1060 ASSERT_EQ(alignment, 2);
1061 }
1062 }
1063
1064 /**
1065 * @tc.number : VIDEO_SWDEC_CAP_API_3610
1066 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
1067 * @tc.desc : api test
1068 */
1069 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3610, TestSize.Level2)
1070 {
1071 if (!access("/system/lib64/media/", 0)) {
1072 OH_AVErrCode ret = AV_ERR_OK;
1073 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1074 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1075 ASSERT_NE(nullptr, capability);
1076 int32_t alignment = 0;
1077 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
1078 ASSERT_EQ(AV_ERR_OK, ret);
1079 ASSERT_GE(alignment, 0);
1080 }
1081 }
1082
1083 /**
1084 * @tc.number : VIDEO_SWDEC_CAP_API_3700
1085 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1086 * @tc.desc : api test
1087 */
1088 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3700, TestSize.Level2)
1089 {
1090 if (!access("/system/lib64/media/", 0)) {
1091 OH_AVErrCode ret = AV_ERR_OK;
1092 OH_AVRange range;
1093 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1094 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1095 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1096 ASSERT_NE(nullptr, capability);
1097 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_HEIGHT, &range);
1098 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1099 }
1100 }
1101
1102 /**
1103 * @tc.number : VIDEO_SWDEC_CAP_API_3800
1104 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1105 * @tc.desc : api test
1106 */
1107 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3800, TestSize.Level2)
1108 {
1109 if (!access("/system/lib64/media/", 0)) {
1110 OH_AVErrCode ret = AV_ERR_OK;
1111 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1112 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1113 ASSERT_NE(nullptr, capability);
1114 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, nullptr);
1115 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1116 }
1117 }
1118
1119 /**
1120 * @tc.number : VIDEO_SWDEC_CAP_API_3900
1121 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1122 * @tc.desc : api test
1123 */
1124 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_3900, TestSize.Level2)
1125 {
1126 if (!access("/system/lib64/media/", 0)) {
1127 OH_AVErrCode ret = AV_ERR_OK;
1128 OH_AVRange range;
1129 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1130 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1131 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1132 ASSERT_NE(nullptr, capability);
1133 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
1134 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1135 }
1136 }
1137
1138 /**
1139 * @tc.number : VIDEO_SWDEC_CAP_API_002
1140 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1141 * @tc.desc : api test
1142 */
1143 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_002, TestSize.Level2)
1144 {
1145 if (!access("/system/lib64/media/", 0)) {
1146 OH_AVErrCode ret = AV_ERR_OK;
1147 OH_AVRange range;
1148 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1149 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1150 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1151 ASSERT_NE(nullptr, capability);
1152 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, -1, &range);
1153 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1154 }
1155 }
1156
1157 /**
1158 * @tc.number : VIDEO_SWDEC_CAP_API_004
1159 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1160 * @tc.desc : api test
1161 */
1162 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_004, TestSize.Level2)
1163 {
1164 if (!access("/system/lib64/media/", 0)) {
1165 OH_AVErrCode ret = AV_ERR_OK;
1166 OH_AVRange range;
1167 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1168 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1169 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1170 ASSERT_NE(nullptr, capability);
1171 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 9999, &range);
1172 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1173 }
1174 }
1175
1176 /**
1177 * @tc.number : VIDEO_SWDEC_CAP_API_005
1178 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1179 * @tc.desc : api test
1180 */
1181 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_005, TestSize.Level2)
1182 {
1183 if (!access("/system/lib64/media/", 0)) {
1184 OH_AVErrCode ret = AV_ERR_OK;
1185 OH_AVRange range;
1186 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1187 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1188 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1189 ASSERT_NE(nullptr, capability);
1190 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 2, nullptr);
1191 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1192 }
1193 }
1194
1195 /**
1196 * @tc.number : VIDEO_SWDEC_CAP_API_4000
1197 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1198 * @tc.desc : api test
1199 */
1200 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4000, TestSize.Level2)
1201 {
1202 if (!access("/system/lib64/media/", 0)) {
1203 OH_AVErrCode ret = AV_ERR_OK;
1204 OH_AVRange range;
1205 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1206 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1207 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1208 ASSERT_NE(nullptr, capability);
1209 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
1210 ASSERT_EQ(AV_ERR_OK, ret);
1211 ASSERT_GE(range.minVal, 0);
1212 ASSERT_GT(range.maxVal, 0);
1213 ASSERT_EQ(range.minVal, 2);
1214 ASSERT_EQ(range.maxVal, 1920);
1215 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1216 ASSERT_NE(nullptr, vdec_);
1217 format = OH_AVFormat_Create();
1218 ASSERT_NE(nullptr, format);
1219 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1220 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1221 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1222 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1223 OH_VideoDecoder_Destroy(vdec_);
1224 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1225 ASSERT_NE(nullptr, vdec_);
1226 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1227 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1228 }
1229 }
1230
1231 /**
1232 * @tc.number : VIDEO_SWDEC_CAP_API_4010
1233 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1234 * @tc.desc : api test //ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1235 */
1236 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4010, TestSize.Level2)
1237 {
1238 if (!access("/system/lib64/media/", 0)) {
1239 OH_AVErrCode ret = AV_ERR_OK;
1240 OH_AVRange range;
1241 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1242 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1243 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1244 ASSERT_NE(nullptr, capability);
1245 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
1246 ASSERT_EQ(AV_ERR_OK, ret);
1247 ASSERT_GE(range.minVal, 0);
1248 ASSERT_GT(range.maxVal, 0);
1249 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1250 ASSERT_NE(nullptr, vdec_);
1251 format = OH_AVFormat_Create();
1252 ASSERT_NE(nullptr, format);
1253 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1254 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1255 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1256 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1257 OH_VideoDecoder_Destroy(vdec_);
1258 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1259 ASSERT_NE(nullptr, vdec_);
1260 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1261 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1262 }
1263 }
1264
1265 /**
1266 * @tc.number : VIDEO_SWDEC_CAP_API_4100
1267 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1268 * @tc.desc : api test
1269 */
1270 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)
1271 {
1272 if (!access("/system/lib64/media/", 0)) {
1273 OH_AVErrCode ret = AV_ERR_OK;
1274 OH_AVRange range;
1275 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1276 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1277 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1278 ASSERT_NE(nullptr, capability);
1279 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1280 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1281 }
1282 }
1283
1284 /**
1285 * @tc.number : VIDEO_SWDEC_CAP_API_4200
1286 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1287 * @tc.desc : api test
1288 */
1289 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)
1290 {
1291 if (!access("/system/lib64/media/", 0)) {
1292 OH_AVErrCode ret = AV_ERR_OK;
1293 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1294 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1295 ASSERT_NE(nullptr, capability);
1296 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1297 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1298 }
1299 }
1300
1301 /**
1302 * @tc.number : VIDEO_SWDEC_CAP_API_007
1303 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1304 * @tc.desc : api test
1305 */
1306 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_007, TestSize.Level2)
1307 {
1308 if (!access("/system/lib64/media/", 0)) {
1309 OH_AVErrCode ret = AV_ERR_OK;
1310 OH_AVRange range;
1311 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1312 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1313 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1314 ASSERT_NE(nullptr, capability);
1315 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, -1, &range);
1316 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1317 }
1318 }
1319
1320 /**
1321 * @tc.number : VIDEO_SWDEC_CAP_API_008
1322 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1323 * @tc.desc : api test
1324 */
1325 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_008, TestSize.Level2)
1326 {
1327 if (!access("/system/lib64/media/", 0)) {
1328 OH_AVErrCode ret = AV_ERR_OK;
1329 OH_AVRange range;
1330 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1331 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1332 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1333 ASSERT_NE(nullptr, capability);
1334 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1335 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1336 }
1337 }
1338
1339 /**
1340 * @tc.number : VIDEO_SWDEC_CAP_API_009
1341 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1342 * @tc.desc : api test
1343 */
1344 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_009, TestSize.Level2)
1345 {
1346 if (!access("/system/lib64/media/", 0)) {
1347 OH_AVErrCode ret = AV_ERR_OK;
1348 OH_AVRange range;
1349 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1350 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1351 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1352 ASSERT_NE(nullptr, capability);
1353 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 9999, &range);
1354 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1355 }
1356 }
1357
1358 /**
1359 * @tc.number : VIDEO_SWDEC_CAP_API_010
1360 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1361 * @tc.desc : api test
1362 */
1363 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_010, TestSize.Level2)
1364 {
1365 if (!access("/system/lib64/media/", 0)) {
1366 OH_AVErrCode ret = AV_ERR_OK;
1367 OH_AVRange range;
1368 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1369 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1370 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1371 ASSERT_NE(nullptr, capability);
1372 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 9999, &range);
1373 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1374 }
1375 }
1376
1377 /**
1378 * @tc.number : VIDEO_SWDEC_CAP_API_4300
1379 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1380 * @tc.desc : api test
1381 */
1382 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)
1383 {
1384 if (!access("/system/lib64/media/", 0)) {
1385 OH_AVErrCode ret = AV_ERR_OK;
1386 OH_AVRange range;
1387 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1388 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1389 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1390 ASSERT_NE(nullptr, capability);
1391 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1392 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1393 }
1394 }
1395
1396 /**
1397 * @tc.number : VIDEO_SWDEC_CAP_API_4400
1398 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1399 * @tc.desc : api test
1400 */
1401 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)
1402 {
1403 if (!access("/system/lib64/media/", 0)) {
1404 OH_AVErrCode ret = AV_ERR_OK;
1405 OH_AVRange range;
1406 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1407 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1408 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1409 ASSERT_NE(nullptr, capability);
1410 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1411 ASSERT_EQ(AV_ERR_OK, ret);
1412 ASSERT_GE(range.minVal, 0);
1413 ASSERT_GT(range.maxVal, 0);
1414 ASSERT_EQ(range.minVal, 2);
1415 ASSERT_EQ(range.maxVal, 1920);
1416 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1417 ASSERT_NE(nullptr, vdec_);
1418 format = OH_AVFormat_Create();
1419 ASSERT_NE(nullptr, format);
1420 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1421 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1422 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1423 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1424 OH_VideoDecoder_Destroy(vdec_);
1425 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1426 ASSERT_NE(nullptr, vdec_);
1427 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1428 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1429 }
1430 }
1431
1432 /**
1433 * @tc.number : VIDEO_SWDEC_CAP_API_4410
1434 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1435 * @tc.desc : api test
1436 */
1437 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4410, TestSize.Level2)
1438 {
1439 if (!access("/system/lib64/media/", 0)) {
1440 OH_AVErrCode ret = AV_ERR_OK;
1441 OH_AVRange range;
1442 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1443 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1444 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1445 ASSERT_NE(nullptr, capability);
1446 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1447 ASSERT_EQ(AV_ERR_OK, ret);
1448 ASSERT_GE(range.minVal, 0);
1449 ASSERT_GT(range.maxVal, 0);
1450 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1451 ASSERT_NE(nullptr, vdec_);
1452 format = OH_AVFormat_Create();
1453 ASSERT_NE(nullptr, format);
1454 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1455 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1456 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1457 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1458 OH_VideoDecoder_Destroy(vdec_);
1459 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1460 ASSERT_NE(nullptr, vdec_);
1461 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1462 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1463 }
1464 }
1465
1466 /**
1467 * @tc.number : VIDEO_SWDEC_CAP_API_4500
1468 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1469 * @tc.desc : api test
1470 */
1471 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)
1472 {
1473 if (!access("/system/lib64/media/", 0)) {
1474 OH_AVErrCode ret = AV_ERR_OK;
1475 OH_AVRange range;
1476 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1477 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1478 }
1479 }
1480
1481 /**
1482 * @tc.number : VIDEO_SWDEC_CAP_API_4600
1483 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1484 * @tc.desc : api test
1485 */
1486 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)
1487 {
1488 if (!access("/system/lib64/media/", 0)) {
1489 OH_AVErrCode ret = AV_ERR_OK;
1490 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1491 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1492 ASSERT_NE(nullptr, capability);
1493 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1494 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1495 }
1496 }
1497
1498 /**
1499 * @tc.number : VIDEO_SWDEC_CAP_API_4700
1500 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1501 * @tc.desc : api test
1502 */
1503 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, TestSize.Level2)
1504 {
1505 if (!access("/system/lib64/media/", 0)) {
1506 OH_AVErrCode ret = AV_ERR_OK;
1507 OH_AVRange range;
1508 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1509 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1510 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1511 ASSERT_NE(nullptr, capability);
1512 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1513 ASSERT_EQ(AV_ERR_OK, ret);
1514 ASSERT_GE(range.minVal, 0);
1515 ASSERT_GT(range.maxVal, 0);
1516 ASSERT_EQ(range.minVal, 2);
1517 ASSERT_EQ(range.maxVal, 1920);
1518 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1519 ASSERT_NE(nullptr, vdec_);
1520 format = OH_AVFormat_Create();
1521 ASSERT_NE(nullptr, format);
1522 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1523 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1524 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1525 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1526 OH_VideoDecoder_Destroy(vdec_);
1527 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1528 ASSERT_NE(nullptr, vdec_);
1529 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1530 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1531 }
1532 }
1533
1534 /**
1535 * @tc.number : VIDEO_SWDEC_CAP_API_4710
1536 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1537 * @tc.desc : api test
1538 */
1539 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4710, TestSize.Level2)
1540 {
1541 if (!access("/system/lib64/media/", 0)) {
1542 OH_AVErrCode ret = AV_ERR_OK;
1543 OH_AVRange range;
1544 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1545 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1546 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1547 ASSERT_NE(nullptr, capability);
1548 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1549 ASSERT_EQ(AV_ERR_OK, ret);
1550 ASSERT_GE(range.minVal, 0);
1551 ASSERT_GT(range.maxVal, 0);
1552 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1553 ASSERT_NE(nullptr, vdec_);
1554 format = OH_AVFormat_Create();
1555 ASSERT_NE(nullptr, format);
1556 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1557 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1558 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1559 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1560 OH_VideoDecoder_Destroy(vdec_);
1561 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1562 ASSERT_NE(nullptr, vdec_);
1563 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1564 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1565 }
1566 }
1567
1568 /**
1569 * @tc.number : VIDEO_SWDEC_CAP_API_4800
1570 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1571 * @tc.desc : api test
1572 */
1573 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)
1574 {
1575 if (!access("/system/lib64/media/", 0)) {
1576 OH_AVErrCode ret = AV_ERR_OK;
1577 OH_AVRange range;
1578 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1579 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1580 }
1581 }
1582
1583 /**
1584 * @tc.number : VIDEO_SWDEC_CAP_API_4900
1585 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1586 * @tc.desc : api test
1587 */
1588 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)
1589 {
1590 if (!access("/system/lib64/media/", 0)) {
1591 OH_AVErrCode ret = AV_ERR_OK;
1592 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1593 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1594 ASSERT_NE(nullptr, capability);
1595 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1596 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1597 }
1598 }
1599
1600 /**
1601 * @tc.number : VIDEO_SWDEC_CAP_API_5000
1602 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1603 * @tc.desc : api test
1604 */
1605 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)
1606 {
1607 if (!access("/system/lib64/media/", 0)) {
1608 OH_AVErrCode ret = AV_ERR_OK;
1609 OH_AVRange widthRange;
1610 OH_AVRange heightRange;
1611 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1612 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1613 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1614 ASSERT_NE(nullptr, capability);
1615 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1616 ASSERT_EQ(AV_ERR_OK, ret);
1617 ASSERT_GE(heightRange.minVal, 0);
1618 ASSERT_GT(heightRange.maxVal, 0);
1619 ASSERT_EQ(heightRange.minVal, 2);
1620 ASSERT_EQ(heightRange.maxVal, 1920);
1621 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1622 ASSERT_NE(nullptr, vdec_);
1623 format = OH_AVFormat_Create();
1624 ASSERT_NE(nullptr, format);
1625 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1626 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1627 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1628 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1629 OH_VideoDecoder_Destroy(vdec_);
1630 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1631 ASSERT_NE(nullptr, vdec_);
1632 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1633 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1634 }
1635 }
1636
1637 /**
1638 * @tc.number : VIDEO_SWDEC_CAP_API_1700
1639 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1640 * @tc.desc : api test
1641 */
1642 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1700, TestSize.Level2)
1643 {
1644 if (!access("/system/lib64/media/", 0)) {
1645 OH_AVErrCode ret = AV_ERR_OK;
1646 OH_AVRange widthRange;
1647 OH_AVRange heightRange;
1648 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1649 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1650 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1651 ASSERT_NE(nullptr, capability);
1652 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1653 ASSERT_EQ(AV_ERR_OK, ret);
1654 ASSERT_GE(heightRange.minVal, 0);
1655 ASSERT_GT(heightRange.maxVal, 0);
1656 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1657 ASSERT_EQ(AV_ERR_OK, ret);
1658 ASSERT_GE(widthRange.minVal, 0);
1659 ASSERT_GT(widthRange.maxVal, 0);
1660 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1661 ASSERT_NE(nullptr, vdec_);
1662 format = OH_AVFormat_Create();
1663 ASSERT_NE(nullptr, format);
1664 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1665 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1666 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1667 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1668 OH_VideoDecoder_Destroy(vdec_);
1669 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1670 ASSERT_NE(nullptr, vdec_);
1671 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1672 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1673 }
1674 }
1675
1676 /**
1677 * @tc.number : VIDEO_SWDEC_CAP_API_5100
1678 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1679 * @tc.desc : api test
1680 */
1681 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)
1682 {
1683 if (!access("/system/lib64/media/", 0)) {
1684 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1685 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1686 ASSERT_NE(nullptr, capability);
1687 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1688 }
1689 }
1690
1691 /**
1692 * @tc.number : VIDEO_SWDEC_CAP_API_5200
1693 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1694 * @tc.desc : api test
1695 */
1696 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)
1697 {
1698 if (!access("/system/lib64/media/", 0)) {
1699 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1700 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1701 ASSERT_NE(nullptr, capability);
1702 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1703 }
1704 }
1705 /**
1706 * @tc.number : VIDEO_SWDEC_CAP_API_5300
1707 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1708 * @tc.desc : api test
1709 */
1710 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)
1711 {
1712 if (!access("/system/lib64/media/", 0)) {
1713 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(
1714 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1715 }
1716 }
1717 /**
1718 * @tc.number : VIDEO_SWDEC_CAP_API_9400
1719 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1720 * @tc.desc : api test
1721 */
1722 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)
1723 {
1724 if (!access("/system/lib64/media/", 0)) {
1725 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1726 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1727 ASSERT_NE(nullptr, capability);
1728 OH_AVRange heightRange;
1729 OH_AVRange widthRange;
1730 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoHeightRange(capability, &heightRange));
1731 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoWidthRange(capability, &widthRange));
1732 ASSERT_EQ(false,
1733 OH_AVCapability_IsVideoSizeSupported(capability, widthRange.maxVal + 1, heightRange.maxVal + 1));
1734 }
1735 }
1736 /**
1737 * @tc.number : VIDEO_SWDEC_CAP_API_5400
1738 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1739 * @tc.desc : api test
1740 */
1741 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)
1742 {
1743 if (!access("/system/lib64/media/", 0)) {
1744 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1745 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1746 ASSERT_NE(nullptr, capability);
1747 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1748 }
1749 }
1750 /**
1751 * @tc.number : VIDEO_SWDEC_CAP_API_5410
1752 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1753 * @tc.desc : api test
1754 */
1755 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5410, TestSize.Level2)
1756 {
1757 if (!access("/system/lib64/media/", 0)) {
1758 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1759 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1760 ASSERT_NE(nullptr, capability);
1761 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1762 }
1763 }
1764
1765 /**
1766 * @tc.number : VIDEO_SWDEC_CAP_API_5500
1767 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1768 * @tc.desc : api test
1769 */
1770 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)
1771 {
1772 if (!access("/system/lib64/media/", 0)) {
1773 OH_AVErrCode ret = AV_ERR_OK;
1774 OH_AVRange range;
1775 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1776 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1777 }
1778 }
1779
1780 /**
1781 * @tc.number : VIDEO_SWDEC_CAP_API_5600
1782 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1783 * @tc.desc : api test
1784 */
1785 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)
1786 {
1787 if (!access("/system/lib64/media/", 0)) {
1788 OH_AVErrCode ret = AV_ERR_OK;
1789 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1790 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1791 ASSERT_NE(nullptr, capability);
1792 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1793 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1794 }
1795 }
1796
1797 /**
1798 * @tc.number : VIDEO_SWDEC_CAP_API_5700
1799 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1800 * @tc.desc : api test
1801 */
1802 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)
1803 {
1804 if (!access("/system/lib64/media/", 0)) {
1805 OH_AVErrCode ret = AV_ERR_OK;
1806 OH_AVRange range;
1807 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1808 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1809 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1810 ASSERT_NE(nullptr, capability);
1811 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1812 ASSERT_EQ(AV_ERR_OK, ret);
1813 ASSERT_GE(range.minVal, 0);
1814 ASSERT_GT(range.maxVal, 0);
1815 }
1816 }
1817
1818 /**
1819 * @tc.number : VIDEO_SWDEC_CAP_API_1600
1820 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1821 * @tc.desc : api test
1822 */
1823 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1600, TestSize.Level2)
1824 {
1825 if (!access("/system/lib64/media/", 0)) {
1826 OH_AVErrCode ret = AV_ERR_OK;
1827 OH_AVRange range;
1828 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1829 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1830 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1831 ASSERT_NE(nullptr, capability);
1832 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1833 ASSERT_EQ(AV_ERR_OK, ret);
1834 ASSERT_GE(range.minVal, 0);
1835 ASSERT_GT(range.maxVal, 0);
1836 ASSERT_EQ(range.minVal, 0);
1837 ASSERT_EQ(range.maxVal, 30);
1838 }
1839 }
1840
1841 /**
1842 * @tc.number : VIDEO_SWDEC_CAP_API_5800
1843 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1844 * @tc.desc : api test
1845 */
1846 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)
1847 {
1848 if (!access("/system/lib64/media/", 0)) {
1849 OH_AVErrCode ret = AV_ERR_OK;
1850 OH_AVRange range;
1851 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1852 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1853 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1854 }
1855 }
1856
1857 /**
1858 * @tc.number : VIDEO_SWDEC_CAP_API_5900
1859 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1860 * @tc.desc : api test
1861 */
1862 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)
1863 {
1864 if (!access("/system/lib64/media/", 0)) {
1865 OH_AVErrCode ret = AV_ERR_OK;
1866 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1867 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1868 ASSERT_NE(nullptr, capability);
1869 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1870 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1871 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1872 }
1873 }
1874
1875 /**
1876 * @tc.number : VIDEO_SWDEC_CAP_API_6000
1877 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1878 * @tc.desc : api test
1879 */
1880 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)
1881 {
1882 if (!access("/system/lib64/media/", 0)) {
1883 OH_AVErrCode ret = AV_ERR_OK;
1884 OH_AVRange range;
1885 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1886 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1887 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1888 ASSERT_NE(nullptr, capability);
1889 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1890 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1891 }
1892 }
1893
1894 /**
1895 * @tc.number : VIDEO_SWDEC_CAP_API_6100
1896 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1897 * @tc.desc : api test
1898 */
1899 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)
1900 {
1901 if (!access("/system/lib64/media/", 0)) {
1902 OH_AVErrCode ret = AV_ERR_OK;
1903 OH_AVRange range;
1904 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1905 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1906 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1907 ASSERT_NE(nullptr, capability);
1908 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1909 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1910 }
1911 }
1912
1913 /**
1914 * @tc.number : VIDEO_SWDEC_CAP_API_012
1915 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1916 * @tc.desc : api test
1917 */
1918 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_012, TestSize.Level2)
1919 {
1920 if (!access("/system/lib64/media/", 0)) {
1921 OH_AVErrCode ret = AV_ERR_OK;
1922 OH_AVRange range;
1923 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1924 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1925 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1926 ASSERT_NE(nullptr, capability);
1927 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, -1, -1, &range);
1928 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1929 }
1930 }
1931
1932 /**
1933 * @tc.number : VIDEO_SWDEC_CAP_API_013
1934 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1935 * @tc.desc : api test
1936 */
1937 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_013, TestSize.Level2)
1938 {
1939 if (!access("/system/lib64/media/", 0)) {
1940 OH_AVErrCode ret = AV_ERR_OK;
1941 OH_AVRange range;
1942 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1943 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1944 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1945 ASSERT_NE(nullptr, capability);
1946 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, 0, &range);
1947 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1948 }
1949 }
1950
1951 /**
1952 * @tc.number : VIDEO_SWDEC_CAP_API_014
1953 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1954 * @tc.desc : api test
1955 */
1956 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_014, TestSize.Level2)
1957 {
1958 if (!access("/system/lib64/media/", 0)) {
1959 OH_AVErrCode ret = AV_ERR_OK;
1960 OH_AVRange range;
1961 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1962 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1963 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1964 ASSERT_NE(nullptr, capability);
1965 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 9999, 9999, &range);
1966 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1967 }
1968 }
1969
1970 /**
1971 * @tc.number : VIDEO_SWDEC_CAP_API_6200
1972 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1973 * @tc.desc : api test
1974 */
1975 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)
1976 {
1977 if (!access("/system/lib64/media/", 0)) {
1978 OH_AVErrCode ret = AV_ERR_OK;
1979 OH_AVRange range;
1980 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1981 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1982 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1983 ASSERT_NE(nullptr, capability);
1984 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1985 ASSERT_EQ(AV_ERR_OK, ret);
1986 ASSERT_GE(range.minVal, 0);
1987 ASSERT_GT(range.maxVal, 0);
1988 ASSERT_EQ(range.minVal, 0);
1989 ASSERT_EQ(range.maxVal, 30);
1990
1991 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1992 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1993 ASSERT_EQ(AV_ERR_OK, ret);
1994 ASSERT_GE(range.minVal, 0);
1995 ASSERT_GT(range.maxVal, 0);
1996 ASSERT_EQ(range.minVal, 0);
1997 ASSERT_EQ(range.maxVal, 30);
1998 }
1999 }
2000
2001 /**
2002 * @tc.number : VIDEO_SWDEC_CAP_API_6210
2003 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
2004 * @tc.desc : api test
2005 */
2006 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6210, TestSize.Level2)
2007 {
2008 if (!access("/system/lib64/media/", 0)) {
2009 OH_AVErrCode ret = AV_ERR_OK;
2010 OH_AVRange range;
2011 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2012 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2013 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2014 ASSERT_NE(nullptr, capability);
2015 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
2016 ASSERT_EQ(AV_ERR_OK, ret);
2017 }
2018 }
2019
2020 /**
2021 * @tc.number : VIDEO_SWDEC_CAP_API_6300
2022 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2023 * @tc.desc : api test
2024 */
2025 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)
2026 {
2027 if (!access("/system/lib64/media/", 0)) {
2028 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2029 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2030 ASSERT_NE(nullptr, capability);
2031 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
2032 }
2033 }
2034
2035 /**
2036 * @tc.number : VIDEO_SWDEC_CAP_API_6400
2037 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2038 * @tc.desc : api test
2039 */
2040 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)
2041 {
2042 if (!access("/system/lib64/media/", 0)) {
2043 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2044 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2045 ASSERT_NE(nullptr, capability);
2046 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
2047 }
2048 }
2049
2050 /**
2051 * @tc.number : VIDEO_SWDEC_CAP_API_6500
2052 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2053 * @tc.desc : api test
2054 */
2055 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)
2056 {
2057 if (!access("/system/lib64/media/", 0)) {
2058 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2059 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2060 ASSERT_NE(nullptr, capability);
2061 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
2062 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
2063 }
2064 }
2065
2066 /**
2067 * @tc.number : VIDEO_SWDEC_CAP_API_6600
2068 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2069 * @tc.desc : api test
2070 */
2071 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)
2072 {
2073 if (!access("/system/lib64/media/", 0)) {
2074 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
2075 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
2076 }
2077 }
2078
2079 /**
2080 * @tc.number : VIDEO_SWDEC_CAP_API_6700
2081 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
2082 * @tc.desc : api test
2083 */
2084 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)
2085 {
2086 if (!access("/system/lib64/media/", 0)) {
2087 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2088 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2089 ASSERT_NE(nullptr, capability);
2090 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
2091 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
2092 }
2093 }
2094
2095 /**
2096 * @tc.number : VIDEO_SWDEC_CAP_API_6710
2097 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
2098 * @tc.desc : api test
2099 */
2100 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6710, TestSize.Level2)
2101 {
2102 if (!access("/system/lib64/media/", 0)) {
2103 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2104 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2105 ASSERT_NE(nullptr, capability);
2106 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
2107 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
2108 }
2109 }
2110
2111 /**
2112 * @tc.number : VIDEO_SWDEC_CAP_API_6800
2113 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
2114 * @tc.desc : api test
2115 */
2116 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)
2117 {
2118 if (!access("/system/lib64/media/", 0)) {
2119 OH_AVErrCode ret = AV_ERR_OK;
2120 const int32_t *pixelFormat = nullptr;
2121 uint32_t pixelFormatNum = 0;
2122 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
2123 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2124 }
2125 }
2126
2127 /**
2128 * @tc.number : VIDEO_SWDEC_CAP_API_6900
2129 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
2130 * @tc.desc : api test
2131 */
2132 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)
2133 {
2134 if (!access("/system/lib64/media/", 0)) {
2135 OH_AVErrCode ret = AV_ERR_OK;
2136 uint32_t pixelFormatNum = 0;
2137 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2138 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2139 ASSERT_NE(nullptr, capability);
2140 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
2141 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2142 }
2143 }
2144
2145 /**
2146 * @tc.number : VIDEO_SWDEC_CAP_API_7000
2147 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
2148 * @tc.desc : api test
2149 */
2150 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)
2151 {
2152 if (!access("/system/lib64/media/", 0)) {
2153 OH_AVErrCode ret = AV_ERR_OK;
2154 const int32_t *pixelFormat = nullptr;
2155 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2156 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2157 ASSERT_NE(nullptr, capability);
2158 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
2159 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2160 }
2161 }
2162
2163 /**
2164 * @tc.number : VIDEO_SWDEC_CAP_API_7100
2165 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
2166 * @tc.desc : api test
2167 */
2168 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)
2169 {
2170 if (!access("/system/lib64/media/", 0)) {
2171 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2172 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2173 ASSERT_NE(nullptr, capability);
2174 ret_1 = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat_1, &pixelFormatNum_1);
2175 ASSERT_NE(nullptr, pixelFormat_1);
2176 ASSERT_GT(pixelFormatNum_1, 0);
2177 ASSERT_EQ(AV_ERR_OK, ret_1);
2178 for (int i = 0; i < pixelFormatNum_1; i++) {
2179 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2180 ASSERT_NE(nullptr, vdec_);
2181 format = OH_AVFormat_Create();
2182 ASSERT_NE(nullptr, format);
2183 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2184 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2185 EXPECT_GE(pixelFormat_1[i], 0);
2186 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat_1[i]);
2187 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2188 OH_AVFormat_Destroy(format);
2189 OH_VideoDecoder_Destroy(vdec_);
2190 }
2191 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2192 ASSERT_NE(nullptr, vdec_);
2193 format = OH_AVFormat_Create();
2194 ASSERT_NE(nullptr, format);
2195 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2196 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2197 (void)OH_AVFormat_SetIntValue(
2198 format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
2199 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2200 OH_VideoDecoder_Destroy(vdec_);
2201 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2202 ASSERT_NE(nullptr, vdec_);
2203 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
2204 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2205 OH_VideoDecoder_Destroy(vdec_);
2206 if (!access("/system/lib64/media/", 0)) {
2207 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2208 ASSERT_NE(nullptr, vdec_);
2209 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
2210 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2211 } else {
2212 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2213 ASSERT_NE(nullptr, vdec_);
2214 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
2215 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2216 }
2217 }
2218 }
2219
2220 /**
2221 * @tc.number : VIDEO_SWDEC_CAP_API_1200
2222 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
2223 * @tc.desc : api test
2224 */
2225 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1200, TestSize.Level2)
2226 {
2227 if (!access("/system/lib64/media/", 0)) {
2228 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2229 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2230 ASSERT_NE(nullptr, capability);
2231 ret_1 = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat_1, &pixelFormatNum_1);
2232 ASSERT_NE(nullptr, pixelFormat_1);
2233 ASSERT_GT(pixelFormatNum_1, 0);
2234 ASSERT_EQ(pixelFormatNum_1, 2);
2235 ASSERT_EQ(AV_ERR_OK, ret_1);
2236 for (int i = 0; i < pixelFormatNum_1; i++) {
2237 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2238 ASSERT_NE(nullptr, vdec_);
2239 format = OH_AVFormat_Create();
2240 ASSERT_NE(nullptr, format);
2241 ASSERT_EQ(pixelFormat_1[0], 2);
2242 ASSERT_EQ(pixelFormat_1[1], 3);
2243 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2244 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2245 EXPECT_GE(pixelFormat_1[i], 0);
2246 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat_1[i]);
2247 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2248 OH_AVFormat_Destroy(format);
2249 OH_VideoDecoder_Destroy(vdec_);
2250 }
2251 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2252 ASSERT_NE(nullptr, vdec_);
2253 format = OH_AVFormat_Create();
2254 ASSERT_NE(nullptr, format);
2255 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2256 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2257 (void)OH_AVFormat_SetIntValue(
2258 format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
2259 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2260 OH_VideoDecoder_Destroy(vdec_);
2261 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2262 ASSERT_NE(nullptr, vdec_);
2263 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
2264 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2265 OH_VideoDecoder_Destroy(vdec_);
2266 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2267 ASSERT_NE(nullptr, vdec_);
2268 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
2269 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2270 }
2271 }
2272
2273 /**
2274 * @tc.number : VIDEO_SWDEC_CAP_API_7200
2275 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2276 * @tc.desc : api test
2277 */
2278 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7200, TestSize.Level2)
2279 {
2280 if (!access("/system/lib64/media/", 0)) {
2281 OH_AVErrCode ret = AV_ERR_OK;
2282 const int32_t *profiles = nullptr;
2283 uint32_t profileNum = 0;
2284 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
2285 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2286 }
2287 }
2288
2289 /**
2290 * @tc.number : VIDEO_SWDEC_CAP_API_7300
2291 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2292 * @tc.desc : api test
2293 */
2294 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7300, TestSize.Level2)
2295 {
2296 if (!access("/system/lib64/media/", 0)) {
2297 OH_AVErrCode ret = AV_ERR_OK;
2298 uint32_t profileNum = 0;
2299 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2300 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2301 ASSERT_NE(nullptr, capability);
2302 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
2303 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2304 }
2305 }
2306
2307 /**
2308 * @tc.number : VIDEO_SWDEC_CAP_API_7400
2309 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2310 * @tc.desc : api test
2311 */
2312 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7400, TestSize.Level2)
2313 {
2314 if (!access("/system/lib64/media/", 0)) {
2315 OH_AVErrCode ret = AV_ERR_OK;
2316 const int32_t *profiles = nullptr;
2317 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2318 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2319 ASSERT_NE(nullptr, capability);
2320 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
2321 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2322 }
2323 }
2324
2325 /**
2326 * @tc.number : VIDEO_SWDEC_CAP_API_7500
2327 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
2328 * @tc.desc : api test
2329 */
2330 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7500, TestSize.Level2)
2331 {
2332 if (!access("/system/lib64/media/", 0)) {
2333 OH_AVErrCode ret = AV_ERR_OK;
2334 const int32_t *profiles = nullptr;
2335 uint32_t profileNum = 0;
2336 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2337 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2338 ASSERT_NE(nullptr, capability);
2339 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2340 ASSERT_EQ(AV_ERR_OK, ret);
2341 ASSERT_EQ(profileNum, 2);
2342 ASSERT_NE(nullptr, profiles);
2343 for (int i = 0; i < profileNum; i++) {
2344 ASSERT_EQ(profiles[i], i);
2345 }
2346 }
2347 }
2348
2349 /**
2350 * @tc.number : VIDEO_SWDEC_CAP_API_1300
2351 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
2352 * @tc.desc : api test
2353 */
2354 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1300, TestSize.Level2)
2355 {
2356 if (!access("/system/lib64/media/", 0)) {
2357 OH_AVErrCode ret = AV_ERR_OK;
2358 const int32_t *profiles = nullptr;
2359 uint32_t profileNum = 0;
2360 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2361 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2362 ASSERT_NE(nullptr, capability);
2363 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2364 ASSERT_EQ(AV_ERR_OK, ret);
2365 ASSERT_GT(profileNum, 0);
2366 ASSERT_NE(nullptr, profiles);
2367 for (int i = 0; i < profileNum; i++) {
2368 EXPECT_GE(profiles[i], 0);
2369 }
2370 }
2371 }
2372
2373 /**
2374 * @tc.number : VIDEO_SWDEC_CAP_API_7600
2375 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2376 * @tc.desc : api test
2377 */
2378 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7600, TestSize.Level2)
2379 {
2380 if (!access("/system/lib64/media/", 0)) {
2381 OH_AVErrCode ret = AV_ERR_OK;
2382 const int32_t *levels = nullptr;
2383 uint32_t levelNum = 0;
2384 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2385 nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
2386 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2387 }
2388 }
2389
2390 /**
2391 * @tc.number : VIDEO_SWDEC_CAP_API_7700
2392 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2393 * @tc.desc : api test
2394 */
2395 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7700, TestSize.Level2)
2396 {
2397 if (!access("/system/lib64/media/", 0)) {
2398 OH_AVErrCode ret = AV_ERR_OK;
2399 const int32_t *levels = nullptr;
2400 uint32_t levelNum = 0;
2401 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2402 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2403 ASSERT_NE(nullptr, capability);
2404 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
2405 ASSERT_EQ(AV_ERR_OK, ret);
2406 }
2407 }
2408
2409 /**
2410 * @tc.number : VIDEO_SWDEC_CAP_API_7800
2411 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2412 * @tc.desc : api test
2413 */
2414 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7800, TestSize.Level2)
2415 {
2416 if (!access("/system/lib64/media/", 0)) {
2417 OH_AVErrCode ret = AV_ERR_OK;
2418 uint32_t levelNum = 0;
2419 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2420 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2421 ASSERT_NE(nullptr, capability);
2422 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2423 capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
2424 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2425 }
2426 }
2427
2428 /**
2429 * @tc.number : VIDEO_SWDEC_CAP_API_7900
2430 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2431 * @tc.desc : api test
2432 */
2433 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7900, TestSize.Level2)
2434 {
2435 if (!access("/system/lib64/media/", 0)) {
2436 OH_AVErrCode ret = AV_ERR_OK;
2437 const int32_t *levels = nullptr;
2438 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2439 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2440 ASSERT_NE(nullptr, capability);
2441 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2442 capability, AVC_PROFILE_BASELINE, &levels, nullptr);
2443 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2444 }
2445 }
2446
2447 /**
2448 * @tc.number : VIDEO_SWDEC_CAP_API_8000
2449 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2450 * @tc.desc : api test
2451 */
2452 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8000, TestSize.Level2)
2453 {
2454 if (!access("/system/lib64/media/", 0)) {
2455 OH_AVErrCode ret = AV_ERR_OK;
2456 const int32_t *levels = nullptr;
2457 uint32_t levelNum = 0;
2458 const int32_t *profiles = nullptr;
2459 uint32_t profileNum = 0;
2460 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2461 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2462 ASSERT_NE(nullptr, capability);
2463 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2464 ASSERT_EQ(AV_ERR_OK, ret);
2465 ASSERT_GT(profileNum, 0);
2466 ASSERT_EQ(profileNum, 2);
2467 ASSERT_NE(nullptr, profiles);
2468 for (int i = 0; i < profileNum; i++) {
2469 ASSERT_EQ(profiles[i], i);
2470 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2471 capability, profiles[i], &levels, &levelNum);
2472 ASSERT_EQ(AV_ERR_OK, ret);
2473 ASSERT_NE(nullptr, levels);
2474 EXPECT_GT(levelNum, 0);
2475 for (int j = 0; j < levelNum; j++) {
2476 EXPECT_EQ(levels[j], j);
2477 }
2478 }
2479 }
2480 }
2481
2482 /**
2483 * @tc.number : VIDEO_SWDEC_CAP_API_1400
2484 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2485 * @tc.desc : api test
2486 */
2487 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1400, TestSize.Level2)
2488 {
2489 if (!access("/system/lib64/media/", 0)) {
2490 OH_AVErrCode ret = AV_ERR_OK;
2491 const int32_t *levels = nullptr;
2492 uint32_t levelNum = 0;
2493 uint32_t profileNum = 0;
2494 const int32_t *profiles = nullptr;
2495 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2496 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2497 ASSERT_NE(nullptr, capability);
2498 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2499 ASSERT_EQ(AV_ERR_OK, ret);
2500 ASSERT_GT(profileNum, 0);
2501 ASSERT_NE(nullptr, profiles);
2502 for (int i = 0; i < profileNum; i++) {
2503 ASSERT_GE(profiles[i], 0);
2504 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2505 capability, profiles[i], &levels, &levelNum);
2506 ASSERT_EQ(AV_ERR_OK, ret);
2507 ASSERT_NE(nullptr, levels);
2508 ASSERT_GT(levelNum, 0);
2509 for (int j = 0; j < levelNum; j++) {
2510 EXPECT_GE(levels[j], 0);
2511 }
2512 }
2513 }
2514 }
2515
2516 /**
2517 * @tc.number : VIDEO_SWDEC_CAP_API_8100
2518 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2519 * @tc.desc : api test
2520 */
2521 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8100, TestSize.Level2)
2522 {
2523 if (!access("/system/lib64/media/", 0)) {
2524 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(
2525 nullptr, AVC_PROFILE_BASELINE, 1));
2526 }
2527 }
2528
2529 /**
2530 * @tc.number : VIDEO_SWDEC_CAP_API_8200
2531 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2532 * @tc.desc : api test
2533 */
2534 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8200, TestSize.Level2)
2535 {
2536 if (!access("/system/lib64/media/", 0)) {
2537 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2538 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2539 ASSERT_NE(nullptr, capability);
2540 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
2541 }
2542 }
2543
2544 /**
2545 * @tc.number : VIDEO_SWDEC_CAP_API_8300
2546 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2547 * @tc.desc : api test
2548 */
2549 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8300, TestSize.Level2)
2550 {
2551 if (!access("/system/lib64/media/", 0)) {
2552 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2553 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2554 ASSERT_NE(nullptr, capability);
2555 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(
2556 capability, HEVC_PROFILE_MAIN_10, 1));
2557 }
2558 }
2559
2560 /**
2561 * @tc.number : VIDEO_SWDEC_CAP_API_8310
2562 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2563 * @tc.desc : api test
2564 */
2565 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8310, TestSize.Level2)
2566 {
2567 if (!access("/system/lib64/media/", 0)) {
2568 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2569 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2570 ASSERT_NE(nullptr, capability);
2571 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(
2572 capability, HEVC_PROFILE_MAIN, 1));
2573 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
2574 }
2575 }
2576
2577 /**
2578 * @tc.number : VIDEO_SWDEC_CAP_API_8400
2579 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2580 * @tc.desc : api test
2581 */
2582 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8400, TestSize.Level2)
2583 {
2584 if (!access("/system/lib64/media/", 0)) {
2585 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2586 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2587 ASSERT_NE(nullptr, capability);
2588 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(capability,
2589 VIDEO_ENCODER_LONG_TERM_REFERENCE);
2590 ASSERT_EQ(nullptr, format);
2591 OH_AVFormat_Destroy(format);
2592 }
2593 }
2594
2595
2596 /**
2597 * @tc.number : VIDEO_SWDEC_CONFIGURE_0010
2598 * @tc.name : set max input size with illegal value
2599 * @tc.desc : api test
2600 */
2601 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0010, TestSize.Level1)
2602 {
2603 if (!access("/system/lib64/media/", 0)) {
2604 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2605 ASSERT_NE(NULL, vdec);
2606 OH_AVFormat *format = OH_AVFormat_Create();
2607 ASSERT_NE(NULL, format);
2608 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2609 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2610 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2611 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, -1);
2612 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2613 OH_VideoDecoder_Destroy(vdec);
2614 OH_AVFormat_Destroy(format);
2615 }
2616 }
2617
2618 /**
2619 * @tc.number : VIDEO_SWDEC_CONFIGURE_0020
2620 * @tc.name : set max input size with illegal value
2621 * @tc.desc : api test
2622 */
2623 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0020, TestSize.Level1)
2624 {
2625 if (!access("/system/lib64/media/", 0)) {
2626 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2627 ASSERT_NE(NULL, vdec);
2628 OH_AVFormat *format = OH_AVFormat_Create();
2629 ASSERT_NE(NULL, format);
2630 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2631 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2632 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2633 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 0);
2634 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2635 OH_VideoDecoder_Destroy(vdec);
2636 OH_AVFormat_Destroy(format);
2637 }
2638 }
2639
2640 /**
2641 * @tc.number : VIDEO_SWDEC_CONFIGURE_0030
2642 * @tc.name : set max input size with illegal value HEVC
2643 * @tc.desc : api test
2644 */
2645 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0030, TestSize.Level1)
2646 {
2647 if (!access("/system/lib64/media/", 0)) {
2648 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2649 ASSERT_NE(NULL, vdec);
2650 OH_AVFormat *format = OH_AVFormat_Create();
2651 ASSERT_NE(NULL, format);
2652 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2653 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2654 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2655 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, -1);
2656 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2657 OH_VideoDecoder_Destroy(vdec);
2658 OH_AVFormat_Destroy(format);
2659 }
2660 }
2661
2662 /**
2663 * @tc.number : VIDEO_SWDEC_CONFIGURE_0040
2664 * @tc.name : set max input size with illegal value HEVC
2665 * @tc.desc : api test
2666 */
2667 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0040, TestSize.Level1)
2668 {
2669 if (!access("/system/lib64/media/", 0)) {
2670 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2671 ASSERT_NE(NULL, vdec);
2672 OH_AVFormat *format = OH_AVFormat_Create();
2673 ASSERT_NE(NULL, format);
2674 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2675 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2676 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2677 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 0);
2678 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2679 OH_VideoDecoder_Destroy(vdec);
2680 OH_AVFormat_Destroy(format);
2681 }
2682 }
2683
2684 /**
2685 * @tc.number : VIDEO_SWDEC_CONFIGURE_0050
2686 * @tc.name : set high rand and width rand, time 100
2687 * @tc.desc : api test
2688 */
2689 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0050, TestSize.Level2)
2690 {
2691 if (!access("/system/lib64/media/", 0)) {
2692 int32_t DEFAULT_HEIGHT = 1920;
2693 int32_t DEFAULT_WIDTH = 1080;
2694 for (int i = 0; i < 100; i++) {
2695 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2696 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2697 ASSERT_NE(nullptr, capability);
2698 DEFAULT_HEIGHT = HighRand();
2699 usleep(1500);
2700 DEFAULT_WIDTH = WidthRand();
2701 usleep(1500);
2702 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability,
2703 DEFAULT_WIDTH, DEFAULT_HEIGHT));
2704 }
2705 }
2706 }
2707
2708 /**
2709 * @tc.number : VIDEO_SWDEC_CONFIGURE_0060
2710 * @tc.name : set high rand, width rand, frame rand time 100
2711 * @tc.desc : api test
2712 */
2713 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0060, TestSize.Level2)
2714 {
2715 if (!access("/system/lib64/media/", 0)) {
2716 double DEFAULT_FRAME_RATE = 30.0;
2717 int32_t DEFAULT_HEIGHT = 1920;
2718 int32_t DEFAULT_WIDTH = 1080;
2719 for (int i = 0; i < 100; i++) {
2720 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2721 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2722 ASSERT_NE(nullptr, capability);
2723 DEFAULT_HEIGHT = HighRand();
2724 usleep(1500);
2725 DEFAULT_WIDTH = WidthRand();
2726 usleep(1500);
2727 DEFAULT_FRAME_RATE = FrameRand();
2728 usleep(1500);
2729 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability,
2730 DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAME_RATE));
2731 }
2732 }
2733 }
2734
2735 /**
2736 * @tc.number : VIDEO_SWDEC_CONFIGURE_0070
2737 * @tc.name : profile and level all support
2738 * @tc.desc : api test
2739 */
2740 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0070, TestSize.Level2)
2741 {
2742 if (!access("/system/lib64/media/", 0)) {
2743 OH_AVErrCode ret = AV_ERR_OK;
2744 const int32_t *levels = nullptr;
2745 uint32_t levelNum = 0;
2746 const int32_t *profiles = nullptr;
2747 uint32_t profileNum = 0;
2748 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2749 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2750 ASSERT_NE(nullptr, capability);
2751 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2752 ASSERT_EQ(AV_ERR_OK, ret);
2753 ASSERT_EQ(profileNum, 2);
2754 ASSERT_NE(nullptr, profiles);
2755 for (int i = 0; i < profileNum; i++) {
2756 ASSERT_EQ(profiles[i], i);
2757 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2758 capability, profiles[i], &levels, &levelNum);
2759 ASSERT_EQ(AV_ERR_OK, ret);
2760 ASSERT_NE(nullptr, levels);
2761 for (int j = 0; j < levelNum; j++) {
2762 ASSERT_EQ(levels[j], j);
2763 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, profiles[i], levels[j]));
2764 }
2765 }
2766 }
2767 }
2768
2769 /**
2770 * @tc.number : VIDEO_SWDEC_CONFIGURE_0080
2771 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2772 * @tc.desc : api test
2773 */
2774 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0080, TestSize.Level2)
2775 {
2776 if (!access("/system/lib64/media/", 0)) {
2777 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2778 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
2779 ASSERT_NE(nullptr, capability);
2780 string g_codecName_hevc_H = OH_AVCapability_GetName(capability);
2781 cout << "g_codecName_hevc_H: " << g_codecName_hevc_H << endl;
2782 OH_AVRange FRateRange;
2783 int ret = OH_AVCapability_GetVideoFrameRateRange(capability, &FRateRange);
2784 cout << "FRateRangeMax = " << FRateRange.maxVal << endl;
2785 cout << "FRateRangeMin = " << FRateRange.minVal << endl;
2786 ASSERT_EQ(AV_ERR_OK, ret);
2787 }
2788 }
2789
2790 /**
2791 * @tc.number : VIDEO_SWDEC_CONFIGURE_0090
2792 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2793 * @tc.desc : api test
2794 */
2795 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0090, TestSize.Level2)
2796 {
2797 if (!access("/system/lib64/media/", 0)) {
2798 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2799 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2800 ASSERT_NE(nullptr, capability);
2801 string g_codecName_hevc_H = OH_AVCapability_GetName(capability);
2802 cout << "g_codecName_hevc_H: " << g_codecName_hevc_H << endl;
2803 OH_AVRange FRateRange;
2804 int ret = OH_AVCapability_GetVideoFrameRateRange(capability, &FRateRange);
2805 cout << "FRateRangeMax = " << FRateRange.maxVal << endl;
2806 cout << "FRateRangeMin = " << FRateRange.minVal << endl;
2807 ASSERT_EQ(AV_ERR_OK, ret);
2808 }
2809 }
2810 } // namespace