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 OH_AVRange heightRange;
1596 OH_AVRange widthRange;
1597 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoHeightRange(capability, &heightRange));
1598 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoWidthRange(capability, &widthRange));
1599 ASSERT_EQ(false,
1600 OH_AVCapability_IsVideoSizeSupported(capability, widthRange.maxVal + 1, heightRange.maxVal + 1));
1601 }
1602 }
1603 /**
1604 * @tc.number : VIDEO_SWDEC_CAP_API_5400
1605 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1606 * @tc.desc : api test
1607 */
1608 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5400, TestSize.Level2)
1609 {
1610 if (!access("/system/lib64/media/", 0)) {
1611 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1612 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1613 ASSERT_NE(nullptr, capability);
1614 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1615 }
1616 }
1617 /**
1618 * @tc.number : VIDEO_SWDEC_CAP_API_5410
1619 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1620 * @tc.desc : api test
1621 */
1622 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5410, TestSize.Level2)
1623 {
1624 if (!access("/system/lib64/media/", 0)) {
1625 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1626 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1627 ASSERT_NE(nullptr, capability);
1628 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1629 }
1630 }
1631
1632 /**
1633 * @tc.number : VIDEO_SWDEC_CAP_API_5500
1634 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1635 * @tc.desc : api test
1636 */
1637 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5500, TestSize.Level2)
1638 {
1639 if (!access("/system/lib64/media/", 0)) {
1640 OH_AVErrCode ret = AV_ERR_OK;
1641 OH_AVRange range;
1642 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1643 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1644 }
1645 }
1646
1647 /**
1648 * @tc.number : VIDEO_SWDEC_CAP_API_5600
1649 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1650 * @tc.desc : api test
1651 */
1652 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5600, TestSize.Level2)
1653 {
1654 if (!access("/system/lib64/media/", 0)) {
1655 OH_AVErrCode ret = AV_ERR_OK;
1656 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1657 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1658 ASSERT_NE(nullptr, capability);
1659 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1660 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1661 }
1662 }
1663
1664 /**
1665 * @tc.number : VIDEO_SWDEC_CAP_API_5700
1666 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1667 * @tc.desc : api test
1668 */
1669 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5700, TestSize.Level2)
1670 {
1671 if (!access("/system/lib64/media/", 0)) {
1672 OH_AVErrCode ret = AV_ERR_OK;
1673 OH_AVRange range;
1674 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1675 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1676 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1677 ASSERT_NE(nullptr, capability);
1678 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1679 ASSERT_EQ(AV_ERR_OK, ret);
1680 ASSERT_GE(range.minVal, 0);
1681 ASSERT_GT(range.maxVal, 0);
1682 }
1683 }
1684
1685 /**
1686 * @tc.number : VIDEO_SWDEC_CAP_API_1600
1687 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1688 * @tc.desc : api test
1689 */
1690 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1600, TestSize.Level2)
1691 {
1692 if (!access("/system/lib64/media/", 0)) {
1693 OH_AVErrCode ret = AV_ERR_OK;
1694 OH_AVRange range;
1695 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1696 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1697 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1698 ASSERT_NE(nullptr, capability);
1699 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1700 ASSERT_EQ(AV_ERR_OK, ret);
1701 ASSERT_GE(range.minVal, 0);
1702 ASSERT_GT(range.maxVal, 0);
1703 ASSERT_EQ(range.minVal, 0);
1704 ASSERT_EQ(range.maxVal, 30);
1705 }
1706 }
1707
1708 /**
1709 * @tc.number : VIDEO_SWDEC_CAP_API_5800
1710 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1711 * @tc.desc : api test
1712 */
1713 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5800, TestSize.Level2)
1714 {
1715 if (!access("/system/lib64/media/", 0)) {
1716 OH_AVErrCode ret = AV_ERR_OK;
1717 OH_AVRange range;
1718 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1719 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1720 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1721 }
1722 }
1723
1724 /**
1725 * @tc.number : VIDEO_SWDEC_CAP_API_5900
1726 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1727 * @tc.desc : api test
1728 */
1729 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_5900, TestSize.Level2)
1730 {
1731 if (!access("/system/lib64/media/", 0)) {
1732 OH_AVErrCode ret = AV_ERR_OK;
1733 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1734 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1735 ASSERT_NE(nullptr, capability);
1736 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1737 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1738 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1739 }
1740 }
1741
1742 /**
1743 * @tc.number : VIDEO_SWDEC_CAP_API_6000
1744 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1745 * @tc.desc : api test
1746 */
1747 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6000, TestSize.Level2)
1748 {
1749 if (!access("/system/lib64/media/", 0)) {
1750 OH_AVErrCode ret = AV_ERR_OK;
1751 OH_AVRange range;
1752 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1753 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1754 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1755 ASSERT_NE(nullptr, capability);
1756 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1757 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1758 }
1759 }
1760
1761 /**
1762 * @tc.number : VIDEO_SWDEC_CAP_API_6100
1763 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1764 * @tc.desc : api test
1765 */
1766 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6100, TestSize.Level2)
1767 {
1768 if (!access("/system/lib64/media/", 0)) {
1769 OH_AVErrCode ret = AV_ERR_OK;
1770 OH_AVRange range;
1771 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1772 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1773 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1774 ASSERT_NE(nullptr, capability);
1775 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1776 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1777 }
1778 }
1779
1780 /**
1781 * @tc.number : VIDEO_SWDEC_CAP_API_6200
1782 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1783 * @tc.desc : api test
1784 */
1785 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6200, TestSize.Level2)
1786 {
1787 if (!access("/system/lib64/media/", 0)) {
1788 OH_AVErrCode ret = AV_ERR_OK;
1789 OH_AVRange range;
1790 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1791 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1792 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1793 ASSERT_NE(nullptr, capability);
1794 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1795 ASSERT_EQ(AV_ERR_OK, ret);
1796 ASSERT_GE(range.minVal, 0);
1797 ASSERT_GT(range.maxVal, 0);
1798 ASSERT_EQ(range.minVal, 0);
1799 ASSERT_EQ(range.maxVal, 30);
1800
1801 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(
1802 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1803 ASSERT_EQ(AV_ERR_OK, ret);
1804 ASSERT_GE(range.minVal, 0);
1805 ASSERT_GT(range.maxVal, 0);
1806 ASSERT_EQ(range.minVal, 0);
1807 ASSERT_EQ(range.maxVal, 30);
1808 }
1809 }
1810
1811 /**
1812 * @tc.number : VIDEO_SWDEC_CAP_API_6210
1813 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1814 * @tc.desc : api test
1815 */
1816 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6210, TestSize.Level2)
1817 {
1818 if (!access("/system/lib64/media/", 0)) {
1819 OH_AVErrCode ret = AV_ERR_OK;
1820 OH_AVRange range;
1821 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1822 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1823 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1824 ASSERT_NE(nullptr, capability);
1825 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1826 ASSERT_EQ(AV_ERR_OK, ret);
1827 }
1828 }
1829
1830 /**
1831 * @tc.number : VIDEO_SWDEC_CAP_API_6300
1832 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1833 * @tc.desc : api test
1834 */
1835 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6300, TestSize.Level2)
1836 {
1837 if (!access("/system/lib64/media/", 0)) {
1838 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1839 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1840 ASSERT_NE(nullptr, capability);
1841 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1842 }
1843 }
1844
1845 /**
1846 * @tc.number : VIDEO_SWDEC_CAP_API_6400
1847 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1848 * @tc.desc : api test
1849 */
1850 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6400, TestSize.Level2)
1851 {
1852 if (!access("/system/lib64/media/", 0)) {
1853 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1854 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1855 ASSERT_NE(nullptr, capability);
1856 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1857 }
1858 }
1859
1860 /**
1861 * @tc.number : VIDEO_SWDEC_CAP_API_6500
1862 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1863 * @tc.desc : api test
1864 */
1865 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6500, TestSize.Level2)
1866 {
1867 if (!access("/system/lib64/media/", 0)) {
1868 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1869 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1870 ASSERT_NE(nullptr, capability);
1871 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1872 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1873 }
1874 }
1875
1876 /**
1877 * @tc.number : VIDEO_SWDEC_CAP_API_6600
1878 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1879 * @tc.desc : api test
1880 */
1881 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6600, TestSize.Level2)
1882 {
1883 if (!access("/system/lib64/media/", 0)) {
1884 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1885 nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1886 }
1887 }
1888
1889 /**
1890 * @tc.number : VIDEO_SWDEC_CAP_API_6700
1891 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1892 * @tc.desc : api test
1893 */
1894 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6700, TestSize.Level2)
1895 {
1896 if (!access("/system/lib64/media/", 0)) {
1897 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1898 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1899 ASSERT_NE(nullptr, capability);
1900 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1901 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1902 }
1903 }
1904
1905 /**
1906 * @tc.number : VIDEO_SWDEC_CAP_API_6710
1907 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1908 * @tc.desc : api test
1909 */
1910 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6710, TestSize.Level2)
1911 {
1912 if (!access("/system/lib64/media/", 0)) {
1913 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1914 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1915 ASSERT_NE(nullptr, capability);
1916 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(
1917 capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1918 }
1919 }
1920
1921 /**
1922 * @tc.number : VIDEO_SWDEC_CAP_API_6800
1923 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1924 * @tc.desc : api test
1925 */
1926 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6800, TestSize.Level2)
1927 {
1928 if (!access("/system/lib64/media/", 0)) {
1929 OH_AVErrCode ret = AV_ERR_OK;
1930 const int32_t *pixelFormat = nullptr;
1931 uint32_t pixelFormatNum = 0;
1932 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1933 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1934 }
1935 }
1936
1937 /**
1938 * @tc.number : VIDEO_SWDEC_CAP_API_6900
1939 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1940 * @tc.desc : api test
1941 */
1942 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_6900, TestSize.Level2)
1943 {
1944 if (!access("/system/lib64/media/", 0)) {
1945 OH_AVErrCode ret = AV_ERR_OK;
1946 uint32_t pixelFormatNum = 0;
1947 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1948 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1949 ASSERT_NE(nullptr, capability);
1950 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1951 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1952 }
1953 }
1954
1955 /**
1956 * @tc.number : VIDEO_SWDEC_CAP_API_7000
1957 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1958 * @tc.desc : api test
1959 */
1960 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7000, TestSize.Level2)
1961 {
1962 if (!access("/system/lib64/media/", 0)) {
1963 OH_AVErrCode ret = AV_ERR_OK;
1964 const int32_t *pixelFormat = nullptr;
1965 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1966 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1967 ASSERT_NE(nullptr, capability);
1968 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1969 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1970 }
1971 }
1972
1973 /**
1974 * @tc.number : VIDEO_SWDEC_CAP_API_7100
1975 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1976 * @tc.desc : api test
1977 */
1978 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7100, TestSize.Level2)
1979 {
1980 if (!access("/system/lib64/media/", 0)) {
1981 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
1982 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
1983 ASSERT_NE(nullptr, capability);
1984 ret_1 = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat_1, &pixelFormatNum_1);
1985 ASSERT_NE(nullptr, pixelFormat_1);
1986 ASSERT_GT(pixelFormatNum_1, 0);
1987 ASSERT_EQ(AV_ERR_OK, ret_1);
1988 for (int i = 0; i < pixelFormatNum_1; i++) {
1989 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
1990 ASSERT_NE(nullptr, vdec_);
1991 format = OH_AVFormat_Create();
1992 ASSERT_NE(nullptr, format);
1993 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1994 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1995 EXPECT_GE(pixelFormat_1[i], 0);
1996 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat_1[i]);
1997 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1998 OH_AVFormat_Destroy(format);
1999 OH_VideoDecoder_Destroy(vdec_);
2000 }
2001 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2002 ASSERT_NE(nullptr, vdec_);
2003 format = OH_AVFormat_Create();
2004 ASSERT_NE(nullptr, format);
2005 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2006 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2007 (void)OH_AVFormat_SetIntValue(
2008 format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
2009 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2010 OH_VideoDecoder_Destroy(vdec_);
2011 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2012 ASSERT_NE(nullptr, vdec_);
2013 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
2014 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2015 OH_VideoDecoder_Destroy(vdec_);
2016 if (!access("/system/lib64/media/", 0)) {
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_RGBA);
2020 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2021 } else {
2022 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2023 ASSERT_NE(nullptr, vdec_);
2024 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
2025 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2026 }
2027 }
2028 }
2029
2030 /**
2031 * @tc.number : VIDEO_SWDEC_CAP_API_1200
2032 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
2033 * @tc.desc : api test
2034 */
2035 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1200, TestSize.Level2)
2036 {
2037 if (!access("/system/lib64/media/", 0)) {
2038 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2039 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2040 ASSERT_NE(nullptr, capability);
2041 ret_1 = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat_1, &pixelFormatNum_1);
2042 ASSERT_NE(nullptr, pixelFormat_1);
2043 ASSERT_GT(pixelFormatNum_1, 0);
2044 ASSERT_EQ(pixelFormatNum_1, 2);
2045 ASSERT_EQ(AV_ERR_OK, ret_1);
2046 for (int i = 0; i < pixelFormatNum_1; i++) {
2047 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2048 ASSERT_NE(nullptr, vdec_);
2049 format = OH_AVFormat_Create();
2050 ASSERT_NE(nullptr, format);
2051 ASSERT_EQ(pixelFormat_1[0], 2);
2052 ASSERT_EQ(pixelFormat_1[1], 3);
2053 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2054 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2055 EXPECT_GE(pixelFormat_1[i], 0);
2056 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat_1[i]);
2057 EXPECT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2058 OH_AVFormat_Destroy(format);
2059 OH_VideoDecoder_Destroy(vdec_);
2060 }
2061 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2062 ASSERT_NE(nullptr, vdec_);
2063 format = OH_AVFormat_Create();
2064 ASSERT_NE(nullptr, format);
2065 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2066 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2067 (void)OH_AVFormat_SetIntValue(
2068 format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
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_YUVI420);
2074 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2075 OH_VideoDecoder_Destroy(vdec_);
2076 vdec_ = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2077 ASSERT_NE(nullptr, vdec_);
2078 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
2079 ASSERT_NE(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
2080 }
2081 }
2082
2083 /**
2084 * @tc.number : VIDEO_SWDEC_CAP_API_7200
2085 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2086 * @tc.desc : api test
2087 */
2088 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7200, TestSize.Level2)
2089 {
2090 if (!access("/system/lib64/media/", 0)) {
2091 OH_AVErrCode ret = AV_ERR_OK;
2092 const int32_t *profiles = nullptr;
2093 uint32_t profileNum = 0;
2094 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
2095 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2096 }
2097 }
2098
2099 /**
2100 * @tc.number : VIDEO_SWDEC_CAP_API_7300
2101 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2102 * @tc.desc : api test
2103 */
2104 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7300, TestSize.Level2)
2105 {
2106 if (!access("/system/lib64/media/", 0)) {
2107 OH_AVErrCode ret = AV_ERR_OK;
2108 uint32_t profileNum = 0;
2109 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2110 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2111 ASSERT_NE(nullptr, capability);
2112 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
2113 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2114 }
2115 }
2116
2117 /**
2118 * @tc.number : VIDEO_SWDEC_CAP_API_7400
2119 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
2120 * @tc.desc : api test
2121 */
2122 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7400, TestSize.Level2)
2123 {
2124 if (!access("/system/lib64/media/", 0)) {
2125 OH_AVErrCode ret = AV_ERR_OK;
2126 const int32_t *profiles = nullptr;
2127 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2128 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2129 ASSERT_NE(nullptr, capability);
2130 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
2131 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2132 }
2133 }
2134
2135 /**
2136 * @tc.number : VIDEO_SWDEC_CAP_API_7500
2137 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
2138 * @tc.desc : api test
2139 */
2140 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7500, TestSize.Level2)
2141 {
2142 if (!access("/system/lib64/media/", 0)) {
2143 OH_AVErrCode ret = AV_ERR_OK;
2144 const int32_t *profiles = nullptr;
2145 uint32_t profileNum = 0;
2146 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2147 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2148 ASSERT_NE(nullptr, capability);
2149 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2150 ASSERT_EQ(AV_ERR_OK, ret);
2151 ASSERT_EQ(profileNum, 2);
2152 ASSERT_NE(nullptr, profiles);
2153 for (int i = 0; i < profileNum; i++) {
2154 ASSERT_EQ(profiles[i], i);
2155 }
2156 }
2157 }
2158
2159 /**
2160 * @tc.number : VIDEO_SWDEC_CAP_API_1300
2161 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
2162 * @tc.desc : api test
2163 */
2164 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1300, TestSize.Level2)
2165 {
2166 if (!access("/system/lib64/media/", 0)) {
2167 OH_AVErrCode ret = AV_ERR_OK;
2168 const int32_t *profiles = nullptr;
2169 uint32_t profileNum = 0;
2170 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2171 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2172 ASSERT_NE(nullptr, capability);
2173 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2174 ASSERT_EQ(AV_ERR_OK, ret);
2175 ASSERT_GT(profileNum, 0);
2176 ASSERT_NE(nullptr, profiles);
2177 for (int i = 0; i < profileNum; i++) {
2178 EXPECT_GE(profiles[i], 0);
2179 }
2180 }
2181 }
2182
2183 /**
2184 * @tc.number : VIDEO_SWDEC_CAP_API_7600
2185 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2186 * @tc.desc : api test
2187 */
2188 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7600, TestSize.Level2)
2189 {
2190 if (!access("/system/lib64/media/", 0)) {
2191 OH_AVErrCode ret = AV_ERR_OK;
2192 const int32_t *levels = nullptr;
2193 uint32_t levelNum = 0;
2194 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2195 nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
2196 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2197 }
2198 }
2199
2200 /**
2201 * @tc.number : VIDEO_SWDEC_CAP_API_7700
2202 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2203 * @tc.desc : api test
2204 */
2205 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7700, TestSize.Level2)
2206 {
2207 if (!access("/system/lib64/media/", 0)) {
2208 OH_AVErrCode ret = AV_ERR_OK;
2209 const int32_t *levels = nullptr;
2210 uint32_t levelNum = 0;
2211 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2212 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2213 ASSERT_NE(nullptr, capability);
2214 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
2215 ASSERT_EQ(AV_ERR_OK, ret);
2216 }
2217 }
2218
2219 /**
2220 * @tc.number : VIDEO_SWDEC_CAP_API_7800
2221 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2222 * @tc.desc : api test
2223 */
2224 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7800, TestSize.Level2)
2225 {
2226 if (!access("/system/lib64/media/", 0)) {
2227 OH_AVErrCode ret = AV_ERR_OK;
2228 uint32_t levelNum = 0;
2229 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2230 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2231 ASSERT_NE(nullptr, capability);
2232 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2233 capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
2234 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2235 }
2236 }
2237
2238 /**
2239 * @tc.number : VIDEO_SWDEC_CAP_API_7900
2240 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2241 * @tc.desc : api test
2242 */
2243 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_7900, TestSize.Level2)
2244 {
2245 if (!access("/system/lib64/media/", 0)) {
2246 OH_AVErrCode ret = AV_ERR_OK;
2247 const int32_t *levels = nullptr;
2248 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2249 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2250 ASSERT_NE(nullptr, capability);
2251 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2252 capability, AVC_PROFILE_BASELINE, &levels, nullptr);
2253 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2254 }
2255 }
2256
2257 /**
2258 * @tc.number : VIDEO_SWDEC_CAP_API_8000
2259 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2260 * @tc.desc : api test
2261 */
2262 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8000, TestSize.Level2)
2263 {
2264 if (!access("/system/lib64/media/", 0)) {
2265 OH_AVErrCode ret = AV_ERR_OK;
2266 const int32_t *levels = nullptr;
2267 uint32_t levelNum = 0;
2268 const int32_t *profiles = nullptr;
2269 uint32_t profileNum = 0;
2270 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2271 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2272 ASSERT_NE(nullptr, capability);
2273 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2274 ASSERT_EQ(AV_ERR_OK, ret);
2275 ASSERT_GT(profileNum, 0);
2276 ASSERT_EQ(profileNum, 2);
2277 ASSERT_NE(nullptr, profiles);
2278 for (int i = 0; i < profileNum; i++) {
2279 ASSERT_EQ(profiles[i], i);
2280 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2281 capability, profiles[i], &levels, &levelNum);
2282 ASSERT_EQ(AV_ERR_OK, ret);
2283 ASSERT_NE(nullptr, levels);
2284 EXPECT_GT(levelNum, 0);
2285 for (int j = 0; j < levelNum; j++) {
2286 EXPECT_EQ(levels[j], j);
2287 }
2288 }
2289 }
2290 }
2291
2292 /**
2293 * @tc.number : VIDEO_SWDEC_CAP_API_1400
2294 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2295 * @tc.desc : api test
2296 */
2297 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_1400, TestSize.Level2)
2298 {
2299 if (!access("/system/lib64/media/", 0)) {
2300 OH_AVErrCode ret = AV_ERR_OK;
2301 const int32_t *levels = nullptr;
2302 uint32_t levelNum = 0;
2303 uint32_t profileNum = 0;
2304 const int32_t *profiles = nullptr;
2305 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2306 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2307 ASSERT_NE(nullptr, capability);
2308 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2309 ASSERT_EQ(AV_ERR_OK, ret);
2310 ASSERT_GT(profileNum, 0);
2311 ASSERT_NE(nullptr, profiles);
2312 for (int i = 0; i < profileNum; i++) {
2313 ASSERT_GE(profiles[i], 0);
2314 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2315 capability, profiles[i], &levels, &levelNum);
2316 ASSERT_EQ(AV_ERR_OK, ret);
2317 ASSERT_NE(nullptr, levels);
2318 ASSERT_GT(levelNum, 0);
2319 for (int j = 0; j < levelNum; j++) {
2320 EXPECT_GE(levels[j], 0);
2321 }
2322 }
2323 }
2324 }
2325
2326 /**
2327 * @tc.number : VIDEO_SWDEC_CAP_API_8100
2328 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2329 * @tc.desc : api test
2330 */
2331 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8100, TestSize.Level2)
2332 {
2333 if (!access("/system/lib64/media/", 0)) {
2334 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(
2335 nullptr, AVC_PROFILE_BASELINE, 1));
2336 }
2337 }
2338
2339 /**
2340 * @tc.number : VIDEO_SWDEC_CAP_API_8200
2341 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2342 * @tc.desc : api test
2343 */
2344 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8200, TestSize.Level2)
2345 {
2346 if (!access("/system/lib64/media/", 0)) {
2347 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2348 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2349 ASSERT_NE(nullptr, capability);
2350 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
2351 }
2352 }
2353
2354 /**
2355 * @tc.number : VIDEO_SWDEC_CAP_API_8300
2356 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2357 * @tc.desc : api test
2358 */
2359 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8300, TestSize.Level2)
2360 {
2361 if (!access("/system/lib64/media/", 0)) {
2362 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2363 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2364 ASSERT_NE(nullptr, capability);
2365 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(
2366 capability, HEVC_PROFILE_MAIN_10, 1));
2367 }
2368 }
2369
2370 /**
2371 * @tc.number : VIDEO_SWDEC_CAP_API_8310
2372 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2373 * @tc.desc : api test
2374 */
2375 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8310, TestSize.Level2)
2376 {
2377 if (!access("/system/lib64/media/", 0)) {
2378 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2379 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2380 ASSERT_NE(nullptr, capability);
2381 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(
2382 capability, HEVC_PROFILE_MAIN, 1));
2383 ASSERT_EQ(false, OH_AVCapability_IsFeatureSupported(capability, VIDEO_ENCODER_TEMPORAL_SCALABILITY));
2384 }
2385 }
2386
2387 /**
2388 * @tc.number : VIDEO_SWDEC_CAP_API_8400
2389 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2390 * @tc.desc : api test
2391 */
2392 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CAP_API_8400, TestSize.Level2)
2393 {
2394 if (!access("/system/lib64/media/", 0)) {
2395 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2396 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2397 ASSERT_NE(nullptr, capability);
2398 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(capability,
2399 VIDEO_ENCODER_LONG_TERM_REFERENCE);
2400 ASSERT_EQ(nullptr, format);
2401 OH_AVFormat_Destroy(format);
2402 }
2403 }
2404
2405
2406 /**
2407 * @tc.number : VIDEO_SWDEC_CONFIGURE_0010
2408 * @tc.name : set max input size with illegal value
2409 * @tc.desc : api test
2410 */
2411 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0010, TestSize.Level1)
2412 {
2413 if (!access("/system/lib64/media/", 0)) {
2414 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2415 ASSERT_NE(NULL, vdec);
2416 OH_AVFormat *format = OH_AVFormat_Create();
2417 ASSERT_NE(NULL, format);
2418 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2419 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2420 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2421 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, -1);
2422 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2423 OH_VideoDecoder_Destroy(vdec);
2424 OH_AVFormat_Destroy(format);
2425 }
2426 }
2427
2428 /**
2429 * @tc.number : VIDEO_SWDEC_CONFIGURE_0020
2430 * @tc.name : set max input size with illegal value
2431 * @tc.desc : api test
2432 */
2433 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0020, TestSize.Level1)
2434 {
2435 if (!access("/system/lib64/media/", 0)) {
2436 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2437 ASSERT_NE(NULL, vdec);
2438 OH_AVFormat *format = OH_AVFormat_Create();
2439 ASSERT_NE(NULL, format);
2440 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2441 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2442 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2443 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 0);
2444 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2445 OH_VideoDecoder_Destroy(vdec);
2446 OH_AVFormat_Destroy(format);
2447 }
2448 }
2449
2450 /**
2451 * @tc.number : VIDEO_SWDEC_CONFIGURE_0030
2452 * @tc.name : set max input size with illegal value HEVC
2453 * @tc.desc : api test
2454 */
2455 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0030, TestSize.Level1)
2456 {
2457 if (!access("/system/lib64/media/", 0)) {
2458 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2459 ASSERT_NE(NULL, vdec);
2460 OH_AVFormat *format = OH_AVFormat_Create();
2461 ASSERT_NE(NULL, format);
2462 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2463 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2464 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2465 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, -1);
2466 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2467 OH_VideoDecoder_Destroy(vdec);
2468 OH_AVFormat_Destroy(format);
2469 }
2470 }
2471
2472 /**
2473 * @tc.number : VIDEO_SWDEC_CONFIGURE_0040
2474 * @tc.name : set max input size with illegal value HEVC
2475 * @tc.desc : api test
2476 */
2477 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0040, TestSize.Level1)
2478 {
2479 if (!access("/system/lib64/media/", 0)) {
2480 OH_AVCodec *vdec = OH_VideoDecoder_CreateByName(g_codecName_hevc.c_str());
2481 ASSERT_NE(NULL, vdec);
2482 OH_AVFormat *format = OH_AVFormat_Create();
2483 ASSERT_NE(NULL, format);
2484 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2485 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2486 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2487 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 0);
2488 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec, format));
2489 OH_VideoDecoder_Destroy(vdec);
2490 OH_AVFormat_Destroy(format);
2491 }
2492 }
2493
2494 /**
2495 * @tc.number : VIDEO_SWDEC_CONFIGURE_0050
2496 * @tc.name : set high rand and width rand, time 100
2497 * @tc.desc : api test
2498 */
2499 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0050, TestSize.Level2)
2500 {
2501 if (!access("/system/lib64/media/", 0)) {
2502 int32_t DEFAULT_HEIGHT = 1920;
2503 int32_t DEFAULT_WIDTH = 1080;
2504 for (int i = 0; i < 100; i++) {
2505 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2506 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2507 ASSERT_NE(nullptr, capability);
2508 DEFAULT_HEIGHT = HighRand();
2509 usleep(1500);
2510 DEFAULT_WIDTH = WidthRand();
2511 usleep(1500);
2512 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability,
2513 DEFAULT_WIDTH, DEFAULT_HEIGHT));
2514 }
2515 }
2516 }
2517
2518 /**
2519 * @tc.number : VIDEO_SWDEC_CONFIGURE_0060
2520 * @tc.name : set high rand, width rand, frame rand time 100
2521 * @tc.desc : api test
2522 */
2523 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0060, TestSize.Level2)
2524 {
2525 if (!access("/system/lib64/media/", 0)) {
2526 double DEFAULT_FRAME_RATE = 30.0;
2527 int32_t DEFAULT_HEIGHT = 1920;
2528 int32_t DEFAULT_WIDTH = 1080;
2529 for (int i = 0; i < 100; i++) {
2530 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2531 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2532 ASSERT_NE(nullptr, capability);
2533 DEFAULT_HEIGHT = HighRand();
2534 usleep(1500);
2535 DEFAULT_WIDTH = WidthRand();
2536 usleep(1500);
2537 DEFAULT_FRAME_RATE = FrameRand();
2538 usleep(1500);
2539 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability,
2540 DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAME_RATE));
2541 }
2542 }
2543 }
2544
2545 /**
2546 * @tc.number : VIDEO_SWDEC_CONFIGURE_0070
2547 * @tc.name : profile and level all support
2548 * @tc.desc : api test
2549 */
2550 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0070, TestSize.Level2)
2551 {
2552 if (!access("/system/lib64/media/", 0)) {
2553 OH_AVErrCode ret = AV_ERR_OK;
2554 const int32_t *levels = nullptr;
2555 uint32_t levelNum = 0;
2556 const int32_t *profiles = nullptr;
2557 uint32_t profileNum = 0;
2558 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2559 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2560 ASSERT_NE(nullptr, capability);
2561 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
2562 ASSERT_EQ(AV_ERR_OK, ret);
2563 ASSERT_EQ(profileNum, 2);
2564 ASSERT_NE(nullptr, profiles);
2565 for (int i = 0; i < profileNum; i++) {
2566 ASSERT_EQ(profiles[i], i);
2567 ret = OH_AVCapability_GetSupportedLevelsForProfile(
2568 capability, profiles[i], &levels, &levelNum);
2569 ASSERT_EQ(AV_ERR_OK, ret);
2570 ASSERT_NE(nullptr, levels);
2571 for (int j = 0; j < levelNum; j++) {
2572 ASSERT_EQ(levels[j], j);
2573 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, profiles[i], levels[j]));
2574 }
2575 }
2576 }
2577 }
2578
2579 /**
2580 * @tc.number : VIDEO_SWDEC_CONFIGURE_0080
2581 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2582 * @tc.desc : api test
2583 */
2584 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0080, TestSize.Level2)
2585 {
2586 if (!access("/system/lib64/media/", 0)) {
2587 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2588 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
2589 ASSERT_NE(nullptr, capability);
2590 string g_codecName_hevc_H = OH_AVCapability_GetName(capability);
2591 cout << "g_codecName_hevc_H: " << g_codecName_hevc_H << endl;
2592 OH_AVRange FRateRange;
2593 int ret = OH_AVCapability_GetVideoFrameRateRange(capability, &FRateRange);
2594 cout << "FRateRangeMax = " << FRateRange.maxVal << endl;
2595 cout << "FRateRangeMin = " << FRateRange.minVal << endl;
2596 ASSERT_EQ(AV_ERR_OK, ret);
2597 }
2598 }
2599
2600 /**
2601 * @tc.number : VIDEO_SWDEC_CONFIGURE_0090
2602 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2603 * @tc.desc : api test
2604 */
2605 HWTEST_F(HevcSwdecApiNdkTest, VIDEO_SWDEC_CONFIGURE_0090, TestSize.Level2)
2606 {
2607 if (!access("/system/lib64/media/", 0)) {
2608 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(
2609 OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
2610 ASSERT_NE(nullptr, capability);
2611 string g_codecName_hevc_H = OH_AVCapability_GetName(capability);
2612 cout << "g_codecName_hevc_H: " << g_codecName_hevc_H << endl;
2613 OH_AVRange FRateRange;
2614 int ret = OH_AVCapability_GetVideoFrameRateRange(capability, &FRateRange);
2615 cout << "FRateRangeMax = " << FRateRange.maxVal << endl;
2616 cout << "FRateRangeMin = " << FRateRange.minVal << endl;
2617 ASSERT_EQ(AV_ERR_OK, ret);
2618 }
2619 }
2620 } // namespace