1 /*
2 * Copyright (C) 2024 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_4000
1140 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1141 * @tc.desc : api test
1142 */
1143 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4000, 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, DEFAULT_HEIGHT, &range);
1153 ASSERT_EQ(AV_ERR_OK, ret);
1154 ASSERT_GE(range.minVal, 0);
1155 ASSERT_GT(range.maxVal, 0);
1156 ASSERT_EQ(range.minVal, 2);
1157 ASSERT_EQ(range.maxVal, 1920);
1158 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1159 ASSERT_NE(nullptr, vdec_);
1160 format = OH_AVFormat_Create();
1161 ASSERT_NE(nullptr, format);
1162 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1163 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1164 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1165 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1166 OH_VideoDecoder_Destroy(vdec_);
1167 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1168 ASSERT_NE(nullptr, vdec_);
1169 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1170 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1171 }
1172 }
1173
1174 /**
1175 * @tc.number : VIDEO_SWDEC_CAP_API_4010
1176 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1177 * @tc.desc : api test //ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1178 */
1179 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4010, TestSize.Level2)
1180 {
1181 if (!access("/system/lib64/media/", 0)) {
1182 OH_AVErrCode ret = AV_ERR_OK;
1183 OH_AVRange range;
1184 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1185 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1186 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1187 ASSERT_NE(nullptr, capability);
1188 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_HEIGHT, &range);
1189 ASSERT_EQ(AV_ERR_OK, ret);
1190 ASSERT_GE(range.minVal, 0);
1191 ASSERT_GT(range.maxVal, 0);
1192 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1193 ASSERT_NE(nullptr, vdec_);
1194 format = OH_AVFormat_Create();
1195 ASSERT_NE(nullptr, format);
1196 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1197 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1198 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1199 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1200 OH_VideoDecoder_Destroy(vdec_);
1201 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1202 ASSERT_NE(nullptr, vdec_);
1203 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1204 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1205 }
1206 }
1207
1208 /**
1209 * @tc.number : VIDEO_SWDEC_CAP_API_4100
1210 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1211 * @tc.desc : api test
1212 */
1213 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4100, TestSize.Level2)
1214 {
1215 if (!access("/system/lib64/media/", 0)) {
1216 OH_AVErrCode ret = AV_ERR_OK;
1217 OH_AVRange range;
1218 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1219 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1220 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1221 ASSERT_NE(nullptr, capability);
1222 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_WIDTH, &range);
1223 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1224 }
1225 }
1226
1227 /**
1228 * @tc.number : VIDEO_SWDEC_CAP_API_4200
1229 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1230 * @tc.desc : api test
1231 */
1232 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4200, TestSize.Level2)
1233 {
1234 if (!access("/system/lib64/media/", 0)) {
1235 OH_AVErrCode ret = AV_ERR_OK;
1236 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1237 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1238 ASSERT_NE(nullptr, capability);
1239 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, nullptr);
1240 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1241 }
1242 }
1243
1244 /**
1245 * @tc.number : VIDEO_SWDEC_CAP_API_4300
1246 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1247 * @tc.desc : api test
1248 */
1249 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4300, TestSize.Level2)
1250 {
1251 if (!access("/system/lib64/media/", 0)) {
1252 OH_AVErrCode ret = AV_ERR_OK;
1253 OH_AVRange range;
1254 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1255 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1256 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1257 ASSERT_NE(nullptr, capability);
1258 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1259 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1260 }
1261 }
1262
1263 /**
1264 * @tc.number : VIDEO_SWDEC_CAP_API_4400
1265 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1266 * @tc.desc : api test
1267 */
1268 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4400, TestSize.Level2)
1269 {
1270 if (!access("/system/lib64/media/", 0)) {
1271 OH_AVErrCode ret = AV_ERR_OK;
1272 OH_AVRange range;
1273 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1274 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1275 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1276 ASSERT_NE(nullptr, capability);
1277 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1278 ASSERT_EQ(AV_ERR_OK, ret);
1279 ASSERT_GE(range.minVal, 0);
1280 ASSERT_GT(range.maxVal, 0);
1281 ASSERT_EQ(range.minVal, 2);
1282 ASSERT_EQ(range.maxVal, 1920);
1283 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1284 ASSERT_NE(nullptr, vdec_);
1285 format = OH_AVFormat_Create();
1286 ASSERT_NE(nullptr, format);
1287 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1288 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1289 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1290 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1291 OH_VideoDecoder_Destroy(vdec_);
1292 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1293 ASSERT_NE(nullptr, vdec_);
1294 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1295 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1296 }
1297 }
1298
1299 /**
1300 * @tc.number : VIDEO_SWDEC_CAP_API_4410
1301 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1302 * @tc.desc : api test
1303 */
1304 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4410, TestSize.Level2)
1305 {
1306 if (!access("/system/lib64/media/", 0)) {
1307 OH_AVErrCode ret = AV_ERR_OK;
1308 OH_AVRange range;
1309 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1310 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1311 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1312 ASSERT_NE(nullptr, capability);
1313 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
1314 ASSERT_EQ(AV_ERR_OK, ret);
1315 ASSERT_GE(range.minVal, 0);
1316 ASSERT_GT(range.maxVal, 0);
1317 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1318 ASSERT_NE(nullptr, vdec_);
1319 format = OH_AVFormat_Create();
1320 ASSERT_NE(nullptr, format);
1321 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1322 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1323 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.minVal - 1);
1324 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1325 OH_VideoDecoder_Destroy(vdec_);
1326 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1327 ASSERT_NE(nullptr, vdec_);
1328 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, range.maxVal + 1);
1329 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1330 }
1331 }
1332
1333 /**
1334 * @tc.number : VIDEO_SWDEC_CAP_API_4500
1335 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1336 * @tc.desc : api test
1337 */
1338 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4500, TestSize.Level2)
1339 {
1340 if (!access("/system/lib64/media/", 0)) {
1341 OH_AVErrCode ret = AV_ERR_OK;
1342 OH_AVRange range;
1343 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1344 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1345 }
1346 }
1347
1348 /**
1349 * @tc.number : VIDEO_SWDEC_CAP_API_4600
1350 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1351 * @tc.desc : api test
1352 */
1353 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4600, TestSize.Level2)
1354 {
1355 if (!access("/system/lib64/media/", 0)) {
1356 OH_AVErrCode ret = AV_ERR_OK;
1357 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1358 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1359 ASSERT_NE(nullptr, capability);
1360 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1361 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1362 }
1363 }
1364
1365 /**
1366 * @tc.number : VIDEO_SWDEC_CAP_API_4700
1367 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1368 * @tc.desc : api test
1369 */
1370 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4700, TestSize.Level2)
1371 {
1372 if (!access("/system/lib64/media/", 0)) {
1373 OH_AVErrCode ret = AV_ERR_OK;
1374 OH_AVRange range;
1375 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1376 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1377 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1378 ASSERT_NE(nullptr, capability);
1379 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1380 ASSERT_EQ(AV_ERR_OK, ret);
1381 ASSERT_GE(range.minVal, 0);
1382 ASSERT_GT(range.maxVal, 0);
1383 ASSERT_EQ(range.minVal, 2);
1384 ASSERT_EQ(range.maxVal, 1920);
1385 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1386 ASSERT_NE(nullptr, vdec_);
1387 format = OH_AVFormat_Create();
1388 ASSERT_NE(nullptr, format);
1389 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1390 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1391 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1392 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1393 OH_VideoDecoder_Destroy(vdec_);
1394 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1395 ASSERT_NE(nullptr, vdec_);
1396 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1397 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1398 }
1399 }
1400
1401 /**
1402 * @tc.number : VIDEO_SWDEC_CAP_API_4710
1403 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1404 * @tc.desc : api test
1405 */
1406 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4710, TestSize.Level2)
1407 {
1408 if (!access("/system/lib64/media/", 0)) {
1409 OH_AVErrCode ret = AV_ERR_OK;
1410 OH_AVRange range;
1411 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1412 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1413 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1414 ASSERT_NE(nullptr, capability);
1415 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1416 ASSERT_EQ(AV_ERR_OK, ret);
1417 ASSERT_GE(range.minVal, 0);
1418 ASSERT_GT(range.maxVal, 0);
1419 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1420 ASSERT_NE(nullptr, vdec_);
1421 format = OH_AVFormat_Create();
1422 ASSERT_NE(nullptr, format);
1423 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1424 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1425 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.minVal - 1);
1426 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1427 OH_VideoDecoder_Destroy(vdec_);
1428 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1429 ASSERT_NE(nullptr, vdec_);
1430 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, range.maxVal + 1);
1431 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1432 }
1433 }
1434
1435 /**
1436 * @tc.number : VIDEO_SWDEC_CAP_API_4800
1437 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1438 * @tc.desc : api test
1439 */
1440 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4800, TestSize.Level2)
1441 {
1442 if (!access("/system/lib64/media/", 0)) {
1443 OH_AVErrCode ret = AV_ERR_OK;
1444 OH_AVRange range;
1445 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1446 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1447 }
1448 }
1449
1450 /**
1451 * @tc.number : VIDEO_SWDEC_CAP_API_4900
1452 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1453 * @tc.desc : api test
1454 */
1455 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_4900, TestSize.Level2)
1456 {
1457 if (!access("/system/lib64/media/", 0)) {
1458 OH_AVErrCode ret = AV_ERR_OK;
1459 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1460 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1461 ASSERT_NE(nullptr, capability);
1462 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1463 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1464 }
1465 }
1466
1467 /**
1468 * @tc.number : VIDEO_SWDEC_CAP_API_5000
1469 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1470 * @tc.desc : api test
1471 */
1472 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5000, TestSize.Level2)
1473 {
1474 if (!access("/system/lib64/media/", 0)) {
1475 OH_AVErrCode ret = AV_ERR_OK;
1476 OH_AVRange widthRange;
1477 OH_AVRange heightRange;
1478 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1479 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1480 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1481 ASSERT_NE(nullptr, capability);
1482 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1483 ASSERT_EQ(AV_ERR_OK, ret);
1484 ASSERT_GE(heightRange.minVal, 0);
1485 ASSERT_GT(heightRange.maxVal, 0);
1486 ASSERT_EQ(heightRange.minVal, 2);
1487 ASSERT_EQ(heightRange.maxVal, 1920);
1488 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1489 ASSERT_NE(nullptr, vdec_);
1490 format = OH_AVFormat_Create();
1491 ASSERT_NE(nullptr, format);
1492 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1493 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1494 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1495 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1496 OH_VideoDecoder_Destroy(vdec_);
1497 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1498 ASSERT_NE(nullptr, vdec_);
1499 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1500 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
1501 }
1502 }
1503
1504 /**
1505 * @tc.number : VIDEO_SWDEC_CAP_API_1700
1506 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1507 * @tc.desc : api test
1508 */
1509 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1700, TestSize.Level2)
1510 {
1511 if (!access("/system/lib64/media/", 0)) {
1512 OH_AVErrCode ret = AV_ERR_OK;
1513 OH_AVRange widthRange;
1514 OH_AVRange heightRange;
1515 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1516 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1517 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1518 ASSERT_NE(nullptr, capability);
1519 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1520 ASSERT_EQ(AV_ERR_OK, ret);
1521 ASSERT_GE(heightRange.minVal, 0);
1522 ASSERT_GT(heightRange.maxVal, 0);
1523 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1524 ASSERT_EQ(AV_ERR_OK, ret);
1525 ASSERT_GE(widthRange.minVal, 0);
1526 ASSERT_GT(widthRange.maxVal, 0);
1527 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1528 ASSERT_NE(nullptr, vdec_);
1529 format = OH_AVFormat_Create();
1530 ASSERT_NE(nullptr, format);
1531 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1532 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1533 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.minVal - 1);
1534 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1535 OH_VideoDecoder_Destroy(vdec_);
1536 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1537 ASSERT_NE(nullptr, vdec_);
1538 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, heightRange.maxVal + 1);
1539 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1540 }
1541 }
1542
1543 /**
1544 * @tc.number : VIDEO_SWDEC_CAP_API_5100
1545 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1546 * @tc.desc : api test
1547 */
1548 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5100, TestSize.Level2)
1549 {
1550 if (!access("/system/lib64/media/", 0)) {
1551 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1552 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1553 ASSERT_NE(nullptr, capability);
1554 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1555 }
1556 }
1557
1558 /**
1559 * @tc.number : VIDEO_SWDEC_CAP_API_5200
1560 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1561 * @tc.desc : api test
1562 */
1563 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5200, TestSize.Level2)
1564 {
1565 if (!access("/system/lib64/media/", 0)) {
1566 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1567 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1568 ASSERT_NE(nullptr, capability);
1569 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1570 }
1571 }
1572 /**
1573 * @tc.number : VIDEO_SWDEC_CAP_API_5300
1574 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1575 * @tc.desc : api test
1576 */
1577 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5300, TestSize.Level2)
1578 {
1579 if (!access("/system/lib64/media/", 0)) {
1580 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(
1581 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1582 }
1583 }
1584 /**
1585 * @tc.number : VIDEO_SWDEC_CAP_API_9400
1586 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1587 * @tc.desc : api test
1588 */
1589 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_9400, TestSize.Level2)
1590 {
1591 if (!access("/system/lib64/media/", 0)) {
1592 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1593 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1594 ASSERT_NE(nullptr, capability);
1595 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 7680, 4320));
1596 }
1597 }
1598 /**
1599 * @tc.number : VIDEO_SWDEC_CAP_API_5400
1600 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1601 * @tc.desc : api test
1602 */
1603 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)
1604 {
1605 if (!access("/system/lib64/media/", 0)) {
1606 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1607 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1608 ASSERT_NE(nullptr, capability);
1609 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1610 }
1611 }
1612 /**
1613 * @tc.number : VIDEO_SWDEC_CAP_API_5410
1614 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1615 * @tc.desc : api test
1616 */
1617 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5410, TestSize.Level2)
1618 {
1619 if (!access("/system/lib64/media/", 0)) {
1620 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1621 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1622 ASSERT_NE(nullptr, capability);
1623 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1624 }
1625 }
1626
1627 /**
1628 * @tc.number : VIDEO_SWDEC_CAP_API_5500
1629 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1630 * @tc.desc : api test
1631 */
1632 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)
1633 {
1634 if (!access("/system/lib64/media/", 0)) {
1635 OH_AVErrCode ret = AV_ERR_OK;
1636 OH_AVRange range;
1637 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1638 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1639 }
1640 }
1641
1642 /**
1643 * @tc.number : VIDEO_SWDEC_CAP_API_5600
1644 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1645 * @tc.desc : api test
1646 */
1647 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)
1648 {
1649 if (!access("/system/lib64/media/", 0)) {
1650 OH_AVErrCode ret = AV_ERR_OK;
1651 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1652 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1653 ASSERT_NE(nullptr, capability);
1654 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1655 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1656 }
1657 }
1658
1659 /**
1660 * @tc.number : VIDEO_SWDEC_CAP_API_5700
1661 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1662 * @tc.desc : api test
1663 */
1664 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)
1665 {
1666 if (!access("/system/lib64/media/", 0)) {
1667 OH_AVErrCode ret = AV_ERR_OK;
1668 OH_AVRange range;
1669 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1670 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1671 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1672 ASSERT_NE(nullptr, capability);
1673 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1674 ASSERT_EQ(AV_ERR_OK, ret);
1675 ASSERT_GE(range.minVal, 0);
1676 ASSERT_GT(range.maxVal, 0);
1677 }
1678 }
1679
1680 /**
1681 * @tc.number : VIDEO_SWDEC_CAP_API_1600
1682 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1683 * @tc.desc : api test
1684 */
1685 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1600, TestSize.Level2)
1686 {
1687 if (!access("/system/lib64/media/", 0)) {
1688 OH_AVErrCode ret = AV_ERR_OK;
1689 OH_AVRange range;
1690 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1691 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1692 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1693 ASSERT_NE(nullptr, capability);
1694 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1695 ASSERT_EQ(AV_ERR_OK, ret);
1696 ASSERT_GE(range.minVal, 0);
1697 ASSERT_GT(range.maxVal, 0);
1698 ASSERT_EQ(range.minVal, 0);
1699 ASSERT_EQ(range.maxVal, 30);
1700 }
1701 }
1702
1703 /**
1704 * @tc.number : VIDEO_SWDEC_CAP_API_5800
1705 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1706 * @tc.desc : api test
1707 */
1708 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)
1709 {
1710 if (!access("/system/lib64/media/", 0)) {
1711 OH_AVErrCode ret = AV_ERR_OK;
1712 OH_AVRange range;
1713 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1714 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1715 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1716 }
1717 }
1718
1719 /**
1720 * @tc.number : VIDEO_SWDEC_CAP_API_5900
1721 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1722 * @tc.desc : api test
1723 */
1724 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)
1725 {
1726 if (!access("/system/lib64/media/", 0)) {
1727 OH_AVErrCode ret = AV_ERR_OK;
1728 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1729 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1730 ASSERT_NE(nullptr, capability);
1731 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1732 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1733 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1734 }
1735 }
1736
1737 /**
1738 * @tc.number : VIDEO_SWDEC_CAP_API_6000
1739 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1740 * @tc.desc : api test
1741 */
1742 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)
1743 {
1744 if (!access("/system/lib64/media/", 0)) {
1745 OH_AVErrCode ret = AV_ERR_OK;
1746 OH_AVRange range;
1747 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1748 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1749 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1750 ASSERT_NE(nullptr, capability);
1751 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1752 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1753 }
1754 }
1755
1756 /**
1757 * @tc.number : VIDEO_SWDEC_CAP_API_6100
1758 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1759 * @tc.desc : api test
1760 */
1761 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)
1762 {
1763 if (!access("/system/lib64/media/", 0)) {
1764 OH_AVErrCode ret = AV_ERR_OK;
1765 OH_AVRange range;
1766 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1767 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1768 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1769 ASSERT_NE(nullptr, capability);
1770 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1771 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1772 }
1773 }
1774
1775 /**
1776 * @tc.number : VIDEO_SWDEC_CAP_API_6200
1777 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1778 * @tc.desc : api test
1779 */
1780 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)
1781 {
1782 if (!access("/system/lib64/media/", 0)) {
1783 OH_AVErrCode ret = AV_ERR_OK;
1784 OH_AVRange range;
1785 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1786 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1787 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1788 ASSERT_NE(nullptr, capability);
1789 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1790 ASSERT_EQ(AV_ERR_OK, ret);
1791 ASSERT_GE(range.minVal, 0);
1792 ASSERT_GT(range.maxVal, 0);
1793 ASSERT_EQ(range.minVal, 0);
1794 ASSERT_EQ(range.maxVal, 30);
1795
1796 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1797 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1798 ASSERT_EQ(AV_ERR_OK, ret);
1799 ASSERT_GE(range.minVal, 0);
1800 ASSERT_GT(range.maxVal, 0);
1801 ASSERT_EQ(range.minVal, 0);
1802 ASSERT_EQ(range.maxVal, 30);
1803 }
1804 }
1805
1806 /**
1807 * @tc.number : VIDEO_SWDEC_CAP_API_6210
1808 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1809 * @tc.desc : api test
1810 */
1811 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6210, TestSize.Level2)
1812 {
1813 if (!access("/system/lib64/media/", 0)) {
1814 OH_AVErrCode ret = AV_ERR_OK;
1815 OH_AVRange range;
1816 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1817 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1818 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1819 ASSERT_NE(nullptr, capability);
1820 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1821 ASSERT_EQ(AV_ERR_OK, ret);
1822 }
1823 }
1824
1825 /**
1826 * @tc.number : VIDEO_SWDEC_CAP_API_6300
1827 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1828 * @tc.desc : api test
1829 */
1830 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)
1831 {
1832 if (!access("/system/lib64/media/", 0)) {
1833 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1834 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1835 ASSERT_NE(nullptr, capability);
1836 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1837 }
1838 }
1839
1840 /**
1841 * @tc.number : VIDEO_SWDEC_CAP_API_6400
1842 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1843 * @tc.desc : api test
1844 */
1845 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)
1846 {
1847 if (!access("/system/lib64/media/", 0)) {
1848 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1849 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1850 ASSERT_NE(nullptr, capability);
1851 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1852 }
1853 }
1854
1855 /**
1856 * @tc.number : VIDEO_SWDEC_CAP_API_6500
1857 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1858 * @tc.desc : api test
1859 */
1860 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)
1861 {
1862 if (!access("/system/lib64/media/", 0)) {
1863 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1864 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1865 ASSERT_NE(nullptr, capability);
1866 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1867 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1868 }
1869 }
1870
1871 /**
1872 * @tc.number : VIDEO_SWDEC_CAP_API_6600
1873 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1874 * @tc.desc : api test
1875 */
1876 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)
1877 {
1878 if (!access("/system/lib64/media/", 0)) {
1879 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1880 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1881 }
1882 }
1883
1884 /**
1885 * @tc.number : VIDEO_SWDEC_CAP_API_6700
1886 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1887 * @tc.desc : api test
1888 */
1889 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)
1890 {
1891 if (!access("/system/lib64/media/", 0)) {
1892 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1893 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1894 ASSERT_NE(nullptr, capability);
1895 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1896 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1897 }
1898 }
1899
1900 /**
1901 * @tc.number : VIDEO_SWDEC_CAP_API_6710
1902 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1903 * @tc.desc : api test
1904 */
1905 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6710, TestSize.Level2)
1906 {
1907 if (!access("/system/lib64/media/", 0)) {
1908 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1909 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1910 ASSERT_NE(nullptr, capability);
1911 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1912 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1913 }
1914 }
1915
1916 /**
1917 * @tc.number : VIDEO_SWDEC_CAP_API_6800
1918 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1919 * @tc.desc : api test
1920 */
1921 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)
1922 {
1923 if (!access("/system/lib64/media/", 0)) {
1924 OH_AVErrCode ret = AV_ERR_OK;
1925 const int32_t *pixelFormat = nullptr;
1926 uint32_t pixelFormatNum = 0;
1927 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1928 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1929 }
1930 }
1931
1932 /**
1933 * @tc.number : VIDEO_SWDEC_CAP_API_6900
1934 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1935 * @tc.desc : api test
1936 */
1937 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)
1938 {
1939 if (!access("/system/lib64/media/", 0)) {
1940 OH_AVErrCode ret = AV_ERR_OK;
1941 uint32_t pixelFormatNum = 0;
1942 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1943 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1944 ASSERT_NE(nullptr, capability);
1945 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1946 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1947 }
1948 }
1949
1950 /**
1951 * @tc.number : VIDEO_SWDEC_CAP_API_7000
1952 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1953 * @tc.desc : api test
1954 */
1955 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)
1956 {
1957 if (!access("/system/lib64/media/", 0)) {
1958 OH_AVErrCode ret = AV_ERR_OK;
1959 const int32_t *pixelFormat = nullptr;
1960 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1961 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1962 ASSERT_NE(nullptr, capability);
1963 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1964 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1965 }
1966 }
1967
1968 /**
1969 * @tc.number : VIDEO_SWDEC_CAP_API_7100
1970 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1971 * @tc.desc : api test
1972 */
1973 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)
1974 {
1975 if (!access("/system/lib64/media/", 0)) {
1976 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1977 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1978 ASSERT_NE(nullptr, capability);
1979 ret_1 = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat_1, &pixelFormatNum_1);
1980 ASSERT_NE(nullptr, pixelFormat_1);
1981 ASSERT_GT(pixelFormatNum_1, 0);
1982 ASSERT_EQ(AV_ERR_OK, ret_1);
1983 for (int i = 0; i < pixelFormatNum_1; i++) {
1984 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1985 ASSERT_NE(nullptr, vdec_);
1986 format = OH_AVFormat_Create();
1987 ASSERT_NE(nullptr, format);
1988 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1989 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1990 EXPECT_GE(pixelFormat_1[i], 0);
1991 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat_1[i]);
1992 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1993 OH_AVFormat_Destroy(format);
1994 OH_VideoDecoder_Destroy(vdec_);
1995 }
1996 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1997 ASSERT_NE(nullptr, vdec_);
1998 format = OH_AVFormat_Create();
1999 ASSERT_NE(nullptr, format);
2000 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2001 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2002 (void)OH_AVFormat_SetIntValue(
2003 format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
2004 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2005 OH_VideoDecoder_Destroy(vdec_);
2006 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2007 ASSERT_NE(nullptr, vdec_);
2008 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
2009 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2010 OH_VideoDecoder_Destroy(vdec_);
2011 if (!access("/system/lib64/media/", 0)) {
2012 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2013 ASSERT_NE(nullptr, vdec_);
2014 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
2015 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2016 } else {
2017 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2018 ASSERT_NE(nullptr, vdec_);
2019 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
2020 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2021 }
2022 }
2023 }
2024
2025 /**
2026 * @tc.number : VIDEO_SWDEC_CAP_API_1200
2027 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
2028 * @tc.desc : api test
2029 */
2030 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1200, TestSize.Level2)
2031 {
2032 if (!access("/system/lib64/media/", 0)) {
2033 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2034 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2035 ASSERT_NE(nullptr, capability);
2036 ret_1 = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat_1, &pixelFormatNum_1);
2037 ASSERT_NE(nullptr, pixelFormat_1);
2038 ASSERT_GT(pixelFormatNum_1, 0);
2039 ASSERT_EQ(pixelFormatNum_1, 2);
2040 ASSERT_EQ(AV_ERR_OK, ret_1);
2041 for (int i = 0; i < pixelFormatNum_1; i++) {
2042 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2043 ASSERT_NE(nullptr, vdec_);
2044 format = OH_AVFormat_Create();
2045 ASSERT_NE(nullptr, format);
2046 ASSERT_EQ(pixelFormat_1[0], 2);
2047 ASSERT_EQ(pixelFormat_1[1], 3);
2048 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2049 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2050 EXPECT_GE(pixelFormat_1[i], 0);
2051 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat_1[i]);
2052 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2053 OH_AVFormat_Destroy(format);
2054 OH_VideoDecoder_Destroy(vdec_);
2055 }
2056 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2057 ASSERT_NE(nullptr, vdec_);
2058 format = OH_AVFormat_Create();
2059 ASSERT_NE(nullptr, format);
2060 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2061 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2062 (void)OH_AVFormat_SetIntValue(
2063 format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
2064 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2065 OH_VideoDecoder_Destroy(vdec_);
2066 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2067 ASSERT_NE(nullptr, vdec_);
2068 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
2069 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2070 OH_VideoDecoder_Destroy(vdec_);
2071 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2072 ASSERT_NE(nullptr, vdec_);
2073 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
2074 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2075 }
2076 }
2077
2078 /**
2079 * @tc.number : VIDEO_SWDEC_CAP_API_7200
2080 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2081 * @tc.desc : api test
2082 */
2083 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7200, TestSize.Level2)
2084 {
2085 if (!access("/system/lib64/media/", 0)) {
2086 OH_AVErrCode ret = AV_ERR_OK;
2087 const int32_t *profiles = nullptr;
2088 uint32_t profileNum = 0;
2089 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
2090 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2091 }
2092 }
2093
2094 /**
2095 * @tc.number : VIDEO_SWDEC_CAP_API_7300
2096 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2097 * @tc.desc : api test
2098 */
2099 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7300, TestSize.Level2)
2100 {
2101 if (!access("/system/lib64/media/", 0)) {
2102 OH_AVErrCode ret = AV_ERR_OK;
2103 uint32_t profileNum = 0;
2104 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2105 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2106 ASSERT_NE(nullptr, capability);
2107 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
2108 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2109 }
2110 }
2111
2112 /**
2113 * @tc.number : VIDEO_SWDEC_CAP_API_7400
2114 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2115 * @tc.desc : api test
2116 */
2117 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7400, TestSize.Level2)
2118 {
2119 if (!access("/system/lib64/media/", 0)) {
2120 OH_AVErrCode ret = AV_ERR_OK;
2121 const int32_t *profiles = nullptr;
2122 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2123 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2124 ASSERT_NE(nullptr, capability);
2125 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
2126 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2127 }
2128 }
2129
2130 /**
2131 * @tc.number : VIDEO_SWDEC_CAP_API_7500
2132 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
2133 * @tc.desc : api test
2134 */
2135 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7500, TestSize.Level2)
2136 {
2137 if (!access("/system/lib64/media/", 0)) {
2138 OH_AVErrCode ret = AV_ERR_OK;
2139 const int32_t *profiles = nullptr;
2140 uint32_t profileNum = 0;
2141 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2142 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2143 ASSERT_NE(nullptr, capability);
2144 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2145 ASSERT_EQ(AV_ERR_OK, ret);
2146 ASSERT_EQ(profileNum, 2);
2147 ASSERT_NE(nullptr, profiles);
2148 for (int i = 0; i < profileNum; i++) {
2149 ASSERT_EQ(profiles[i], i);
2150 }
2151 }
2152 }
2153
2154 /**
2155 * @tc.number : VIDEO_SWDEC_CAP_API_1300
2156 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
2157 * @tc.desc : api test
2158 */
2159 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1300, TestSize.Level2)
2160 {
2161 if (!access("/system/lib64/media/", 0)) {
2162 OH_AVErrCode ret = AV_ERR_OK;
2163 const int32_t *profiles = nullptr;
2164 uint32_t profileNum = 0;
2165 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2166 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2167 ASSERT_NE(nullptr, capability);
2168 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2169 ASSERT_EQ(AV_ERR_OK, ret);
2170 ASSERT_GT(profileNum, 0);
2171 ASSERT_NE(nullptr, profiles);
2172 for (int i = 0; i < profileNum; i++) {
2173 EXPECT_GE(profiles[i], 0);
2174 }
2175 }
2176 }
2177
2178 /**
2179 * @tc.number : VIDEO_SWDEC_CAP_API_7600
2180 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2181 * @tc.desc : api test
2182 */
2183 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7600, TestSize.Level2)
2184 {
2185 if (!access("/system/lib64/media/", 0)) {
2186 OH_AVErrCode ret = AV_ERR_OK;
2187 const int32_t *levels = nullptr;
2188 uint32_t levelNum = 0;
2189 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2190 nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
2191 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2192 }
2193 }
2194
2195 /**
2196 * @tc.number : VIDEO_SWDEC_CAP_API_7700
2197 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2198 * @tc.desc : api test
2199 */
2200 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7700, TestSize.Level2)
2201 {
2202 if (!access("/system/lib64/media/", 0)) {
2203 OH_AVErrCode ret = AV_ERR_OK;
2204 const int32_t *levels = nullptr;
2205 uint32_t levelNum = 0;
2206 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2207 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2208 ASSERT_NE(nullptr, capability);
2209 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
2210 ASSERT_EQ(AV_ERR_OK, ret);
2211 }
2212 }
2213
2214 /**
2215 * @tc.number : VIDEO_SWDEC_CAP_API_7800
2216 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2217 * @tc.desc : api test
2218 */
2219 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7800, TestSize.Level2)
2220 {
2221 if (!access("/system/lib64/media/", 0)) {
2222 OH_AVErrCode ret = AV_ERR_OK;
2223 uint32_t levelNum = 0;
2224 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2225 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2226 ASSERT_NE(nullptr, capability);
2227 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2228 capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
2229 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2230 }
2231 }
2232
2233 /**
2234 * @tc.number : VIDEO_SWDEC_CAP_API_7900
2235 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2236 * @tc.desc : api test
2237 */
2238 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7900, TestSize.Level2)
2239 {
2240 if (!access("/system/lib64/media/", 0)) {
2241 OH_AVErrCode ret = AV_ERR_OK;
2242 const int32_t *levels = nullptr;
2243 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2244 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2245 ASSERT_NE(nullptr, capability);
2246 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2247 capability, AVC_PROFILE_BASELINE, &levels, nullptr);
2248 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2249 }
2250 }
2251
2252 /**
2253 * @tc.number : VIDEO_SWDEC_CAP_API_8000
2254 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2255 * @tc.desc : api test
2256 */
2257 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8000, TestSize.Level2)
2258 {
2259 if (!access("/system/lib64/media/", 0)) {
2260 OH_AVErrCode ret = AV_ERR_OK;
2261 const int32_t *levels = nullptr;
2262 uint32_t levelNum = 0;
2263 const int32_t *profiles = nullptr;
2264 uint32_t profileNum = 0;
2265 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2266 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2267 ASSERT_NE(nullptr, capability);
2268 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2269 ASSERT_EQ(AV_ERR_OK, ret);
2270 ASSERT_GT(profileNum, 0);
2271 ASSERT_EQ(profileNum, 2);
2272 ASSERT_NE(nullptr, profiles);
2273 for (int i = 0; i < profileNum; i++) {
2274 ASSERT_EQ(profiles[i], i);
2275 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2276 capability, profiles[i], &levels, &levelNum);
2277 ASSERT_EQ(AV_ERR_OK, ret);
2278 ASSERT_NE(nullptr, levels);
2279 EXPECT_GT(levelNum, 0);
2280 for (int j = 0; j < levelNum; j++) {
2281 EXPECT_EQ(levels[j], j);
2282 }
2283 }
2284 }
2285 }
2286
2287 /**
2288 * @tc.number : VIDEO_SWDEC_CAP_API_1400
2289 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2290 * @tc.desc : api test
2291 */
2292 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1400, TestSize.Level2)
2293 {
2294 if (!access("/system/lib64/media/", 0)) {
2295 OH_AVErrCode ret = AV_ERR_OK;
2296 const int32_t *levels = nullptr;
2297 uint32_t levelNum = 0;
2298 uint32_t profileNum = 0;
2299 const int32_t *profiles = nullptr;
2300 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2301 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2302 ASSERT_NE(nullptr, capability);
2303 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2304 ASSERT_EQ(AV_ERR_OK, ret);
2305 ASSERT_GT(profileNum, 0);
2306 ASSERT_NE(nullptr, profiles);
2307 for (int i = 0; i < profileNum; i++) {
2308 ASSERT_GE(profiles[i], 0);
2309 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2310 capability, profiles[i], &levels, &levelNum);
2311 ASSERT_EQ(AV_ERR_OK, ret);
2312 ASSERT_NE(nullptr, levels);
2313 ASSERT_GT(levelNum, 0);
2314 for (int j = 0; j < levelNum; j++) {
2315 EXPECT_GE(levels[j], 0);
2316 }
2317 }
2318 }
2319 }
2320
2321 /**
2322 * @tc.number : VIDEO_SWDEC_CAP_API_8100
2323 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2324 * @tc.desc : api test
2325 */
2326 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8100, TestSize.Level2)
2327 {
2328 if (!access("/system/lib64/media/", 0)) {
2329 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(
2330 nullptr, AVC_PROFILE_BASELINE, 1));
2331 }
2332 }
2333
2334 /**
2335 * @tc.number : VIDEO_SWDEC_CAP_API_8200
2336 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2337 * @tc.desc : api test
2338 */
2339 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8200, TestSize.Level2)
2340 {
2341 if (!access("/system/lib64/media/", 0)) {
2342 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2343 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2344 ASSERT_NE(nullptr, capability);
2345 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
2346 }
2347 }
2348
2349 /**
2350 * @tc.number : VIDEO_SWDEC_CAP_API_8300
2351 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2352 * @tc.desc : api test
2353 */
2354 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8300, TestSize.Level2)
2355 {
2356 if (!access("/system/lib64/media/", 0)) {
2357 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2358 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2359 ASSERT_NE(nullptr, capability);
2360 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(
2361 capability, HEVC_PROFILE_MAIN_10, 1));
2362 }
2363 }
2364
2365 /**
2366 * @tc.number : VIDEO_SWDEC_CAP_API_8310
2367 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2368 * @tc.desc : api test
2369 */
2370 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8310, TestSize.Level2)
2371 {
2372 if (!access("/system/lib64/media/", 0)) {
2373 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2374 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2375 ASSERT_NE(nullptr, capability);
2376 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(
2377 capability, HEVC_PROFILE_MAIN, 1));
2378 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
2379 }
2380 }
2381
2382 /**
2383 * @tc.number : VIDEO_SWDEC_CAP_API_8400
2384 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2385 * @tc.desc : api test
2386 */
2387 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8400, TestSize.Level2)
2388 {
2389 if (!access("/system/lib64/media/", 0)) {
2390 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2391 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2392 ASSERT_NE(nullptr, capability);
2393 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(capability,
2394 VIDEO_ENCODER_LONG_TERM_REFERENCE);
2395 ASSERT_EQ(nullptr, format);
2396 OH_AVFormat_Destroy(format);
2397 }
2398 }
2399
2400
2401 /**
2402 * @tc.number : VIDEO_SWDEC_CONFIGURE_0010
2403 * @tc.name : set max input size with illegal value
2404 * @tc.desc : api test
2405 */
2406 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0010, TestSize.Level1)
2407 {
2408 if (!access("/system/lib64/media/", 0)) {
2409 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2410 ASSERT_NE(NULL, vdec);
2411 OH_AVFormat *format = OH_AVFormat_Create();
2412 ASSERT_NE(NULL, format);
2413 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2414 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2415 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2416 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, -1);
2417 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2418 OH_VideoDecoder_Destroy(vdec);
2419 OH_AVFormat_Destroy(format);
2420 }
2421 }
2422
2423 /**
2424 * @tc.number : VIDEO_SWDEC_CONFIGURE_0020
2425 * @tc.name : set max input size with illegal value
2426 * @tc.desc : api test
2427 */
2428 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0020, TestSize.Level1)
2429 {
2430 if (!access("/system/lib64/media/", 0)) {
2431 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2432 ASSERT_NE(NULL, vdec);
2433 OH_AVFormat *format = OH_AVFormat_Create();
2434 ASSERT_NE(NULL, format);
2435 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2436 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2437 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2438 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 0);
2439 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2440 OH_VideoDecoder_Destroy(vdec);
2441 OH_AVFormat_Destroy(format);
2442 }
2443 }
2444
2445 /**
2446 * @tc.number : VIDEO_SWDEC_CONFIGURE_0030
2447 * @tc.name : set max input size with illegal value HEVC
2448 * @tc.desc : api test
2449 */
2450 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0030, TestSize.Level1)
2451 {
2452 if (!access("/system/lib64/media/", 0)) {
2453 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2454 ASSERT_NE(NULL, vdec);
2455 OH_AVFormat *format = OH_AVFormat_Create();
2456 ASSERT_NE(NULL, format);
2457 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2458 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2459 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2460 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, -1);
2461 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2462 OH_VideoDecoder_Destroy(vdec);
2463 OH_AVFormat_Destroy(format);
2464 }
2465 }
2466
2467 /**
2468 * @tc.number : VIDEO_SWDEC_CONFIGURE_0040
2469 * @tc.name : set max input size with illegal value HEVC
2470 * @tc.desc : api test
2471 */
2472 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0040, TestSize.Level1)
2473 {
2474 if (!access("/system/lib64/media/", 0)) {
2475 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2476 ASSERT_NE(NULL, vdec);
2477 OH_AVFormat *format = OH_AVFormat_Create();
2478 ASSERT_NE(NULL, format);
2479 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2480 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2481 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2482 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 0);
2483 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2484 OH_VideoDecoder_Destroy(vdec);
2485 OH_AVFormat_Destroy(format);
2486 }
2487 }
2488
2489 /**
2490 * @tc.number : VIDEO_SWDEC_CONFIGURE_0050
2491 * @tc.name : set high rand and width rand, time 100
2492 * @tc.desc : api test
2493 */
2494 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0050, TestSize.Level2)
2495 {
2496 if (!access("/system/lib64/media/", 0)) {
2497 int32_t DEFAULT_HEIGHT = 1920;
2498 int32_t DEFAULT_WIDTH = 1080;
2499 for (int i = 0; i < 100; i++) {
2500 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2501 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2502 ASSERT_NE(nullptr, capability);
2503 DEFAULT_HEIGHT = HighRand();
2504 usleep(1500);
2505 DEFAULT_WIDTH = WidthRand();
2506 usleep(1500);
2507 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability,
2508 DEFAULT_WIDTH, DEFAULT_HEIGHT));
2509 }
2510 }
2511 }
2512
2513 /**
2514 * @tc.number : VIDEO_SWDEC_CONFIGURE_0060
2515 * @tc.name : set high rand, width rand, frame rand time 100
2516 * @tc.desc : api test
2517 */
2518 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0060, TestSize.Level2)
2519 {
2520 if (!access("/system/lib64/media/", 0)) {
2521 double DEFAULT_FRAME_RATE = 30.0;
2522 int32_t DEFAULT_HEIGHT = 1920;
2523 int32_t DEFAULT_WIDTH = 1080;
2524 for (int i = 0; i < 100; i++) {
2525 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2526 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2527 ASSERT_NE(nullptr, capability);
2528 DEFAULT_HEIGHT = HighRand();
2529 usleep(1500);
2530 DEFAULT_WIDTH = WidthRand();
2531 usleep(1500);
2532 DEFAULT_FRAME_RATE = FrameRand();
2533 usleep(1500);
2534 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability,
2535 DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAME_RATE));
2536 }
2537 }
2538 }
2539
2540 /**
2541 * @tc.number : VIDEO_SWDEC_CONFIGURE_0070
2542 * @tc.name : profile and level all support
2543 * @tc.desc : api test
2544 */
2545 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0070, TestSize.Level2)
2546 {
2547 if (!access("/system/lib64/media/", 0)) {
2548 OH_AVErrCode ret = AV_ERR_OK;
2549 const int32_t *levels = nullptr;
2550 uint32_t levelNum = 0;
2551 const int32_t *profiles = nullptr;
2552 uint32_t profileNum = 0;
2553 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2554 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2555 ASSERT_NE(nullptr, capability);
2556 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2557 ASSERT_EQ(AV_ERR_OK, ret);
2558 ASSERT_EQ(profileNum, 2);
2559 ASSERT_NE(nullptr, profiles);
2560 for (int i = 0; i < profileNum; i++) {
2561 ASSERT_EQ(profiles[i], i);
2562 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2563 capability, profiles[i], &levels, &levelNum);
2564 ASSERT_EQ(AV_ERR_OK, ret);
2565 ASSERT_NE(nullptr, levels);
2566 for (int j = 0; j < levelNum; j++) {
2567 ASSERT_EQ(levels[j], j);
2568 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, profiles[i], levels[j]));
2569 }
2570 }
2571 }
2572 }
2573
2574 /**
2575 * @tc.number : VIDEO_SWDEC_CONFIGURE_0080
2576 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2577 * @tc.desc : api test
2578 */
2579 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0080, TestSize.Level2)
2580 {
2581 if (!access("/system/lib64/media/", 0)) {
2582 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2583 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
2584 ASSERT_NE(nullptr, capability);
2585 string g_codecName_hevc_H = OH_AVCapability_GetName(capability);
2586 cout << "g_codecName_hevc_H: " << g_codecName_hevc_H << endl;
2587 OH_AVRange FRateRange;
2588 int ret = OH_AVCapability_GetVideoFrameRateRange(capability, &FRateRange);
2589 cout << "FRateRangeMax = " << FRateRange.maxVal << endl;
2590 cout << "FRateRangeMin = " << FRateRange.minVal << endl;
2591 ASSERT_EQ(AV_ERR_OK, ret);
2592 }
2593 }
2594
2595 /**
2596 * @tc.number : VIDEO_SWDEC_CONFIGURE_0090
2597 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2598 * @tc.desc : api test
2599 */
2600 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0090, TestSize.Level2)
2601 {
2602 if (!access("/system/lib64/media/", 0)) {
2603 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2604 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2605 ASSERT_NE(nullptr, capability);
2606 string g_codecName_hevc_H = OH_AVCapability_GetName(capability);
2607 cout << "g_codecName_hevc_H: " << g_codecName_hevc_H << endl;
2608 OH_AVRange FRateRange;
2609 int ret = OH_AVCapability_GetVideoFrameRateRange(capability, &FRateRange);
2610 cout << "FRateRangeMax = " << FRateRange.maxVal << endl;
2611 cout << "FRateRangeMin = " << FRateRange.minVal << endl;
2612 ASSERT_EQ(AV_ERR_OK, ret);
2613 }
2614 }
2615 } // namespace