1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <iostream>
17 #include <cstdio>
18 #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_ndk_sample.h"
27 #include "native_avcodec_videodecoder.h"
28 #include "native_avformat.h"
29 #include "native_averrors.h"
30 #include "native_avcodec_base.h"
31 #include "native_avcapability.h"
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace OHOS::Media;
36 using namespace testing::ext;
37 namespace OHOS {
38 namespace Media {
39 class HwdecApiNdkTest : public testing::Test {
40 public:
41 // SetUpTestCase: Called before all test cases
42 static void SetUpTestCase(void);
43 // TearDownTestCase: Called after all test case
44 static void TearDownTestCase(void);
45 // SetUp: Called before each test cases
46 void SetUp(void);
47 // TearDown: Called after each test cases
48 void TearDown(void);
49 };
50
51 namespace {
52 OH_AVCodec *vdec_ = NULL;
53 OH_AVCapability *cap = nullptr;
54 VDecSignal *signal_;
55 const string INVALID_CODEC_NAME = "avdec_h264";
56 const string CODEC_MIME = "video/avc";
57 string g_codecName;
58
59 constexpr uint32_t DEFAULT_WIDTH = 1920;
60 constexpr uint32_t DEFAULT_HEIGHT = 1080;
61 constexpr double DEFAULT_FRAME_RATE = 30.0;
62 } // namespace
63
SetUpTestCase()64 void HwdecApiNdkTest::SetUpTestCase()
65 {
66 cap = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
67 g_codecName = OH_AVCapability_GetName(cap);
68 cout << "g_codecName: " << g_codecName << endl;
69 }
TearDownTestCase()70 void HwdecApiNdkTest::TearDownTestCase() {}
SetUp()71 void HwdecApiNdkTest::SetUp()
72 {
73 signal_ = new VDecSignal();
74 }
TearDown()75 void HwdecApiNdkTest::TearDown()
76 {
77 if (signal_) {
78 delete signal_;
79 signal_ = nullptr;
80 }
81 if (vdec_ != NULL) {
82 OH_VideoDecoder_Destroy(vdec_);
83 vdec_ = nullptr;
84 }
85 }
86 } // namespace Media
87 } // namespace OHOS
88
89 namespace {
VDecNeedInputData(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,void * userData)90 void VDecNeedInputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)
91 {
92 cout << "VDecNeedInputData index:" << index << endl;
93 VDecSignal *signal = static_cast<VDecSignal *>(userData);
94 unique_lock<mutex> lock(signal->inMutex_);
95 signal->inIdxQueue_.push(index);
96 signal->inCond_.notify_all();
97 }
98
99 /**
100 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0100
101 * @tc.name : OH_VideoDecoder_FindDecoder para error
102 * @tc.desc : function test
103 */
104 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0100, TestSize.Level2)
105 {
106 vdec_ = OH_VideoDecoder_CreateByMime(NULL);
107 ASSERT_EQ(NULL, vdec_);
108 }
109
110 /**
111 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0200
112 * @tc.name : OH_VideoDecoder_CreateByName para error
113 * @tc.desc : function test
114 */
115 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0200, TestSize.Level2)
116 {
117 vdec_ = OH_VideoDecoder_CreateByName(NULL);
118 ASSERT_EQ(NULL, vdec_);
119 }
120
121 /**
122 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3300
123 * @tc.name : OH_VideoDecoder_SetCallback para error
124 * @tc.desc : function test
125 */
126 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3300, TestSize.Level2)
127 {
128 OH_AVCodecAsyncCallback cb_;
129 cb_.onError = VdecError;
130 cb_.onStreamChanged = VdecFormatChanged;
131 cb_.onNeedInputData = VdecInputDataReady;
132 cb_.onNeedOutputData = VdecOutputDataReady;
133 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
134 }
135
136 /**
137 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1800
138 * @tc.name : OH_VideoDecoder_SetCallback para error
139 * @tc.desc : function test
140 */
141 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1800, TestSize.Level2)
142 {
143 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
144 ASSERT_NE(NULL, vdec_);
145
146 OH_AVCodecAsyncCallback cb2_;
147 cb2_.onError = NULL;
148 cb2_.onStreamChanged = NULL;
149 cb2_.onNeedInputData = NULL;
150 cb2_.onNeedOutputData = NULL;
151 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb2_, static_cast<void *>(signal_)));
152 }
153
154 /**
155 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0300
156 * @tc.name : OH_VideoDecoder_SetCallback para error
157 * @tc.desc : function test
158 */
159 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0300, TestSize.Level2)
160 {
161 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
162 OH_AVCodecAsyncCallback cb_;
163 cb_.onError = VdecError;
164 cb_.onStreamChanged = VdecFormatChanged;
165 cb_.onNeedInputData = VdecInputDataReady;
166 cb_.onNeedOutputData = VdecOutputDataReady;
167 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
168 }
169
170 /**
171 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0400
172 * @tc.name : OH_VideoDecoder_Destroy para error
173 * @tc.desc : function test
174 */
175 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0400, TestSize.Level2)
176 {
177 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(NULL));
178 }
179
180 /**
181 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0500
182 * @tc.name : OH_VideoDecoder_Configure para error
183 * @tc.desc : function test
184 */
185 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0500, TestSize.Level2)
186 {
187 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
188 ASSERT_NE(NULL, vdec_);
189 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, NULL));
190 }
191
192 /**
193 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1400
194 * @tc.name : OH_VideoDecoder_Configure para error
195 * @tc.desc : function test
196 */
197 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1400, TestSize.Level2)
198 {
199 OH_AVFormat *format = OH_AVFormat_Create();
200 ASSERT_NE(NULL, format);
201 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
202 }
203
204 /**
205 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1400
206 * @tc.name : OH_VideoDecoder_Configure para error
207 * @tc.desc : function test
208 */
209 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_5000, TestSize.Level2)
210 {
211 OH_AVFormat *format = OH_AVFormat_Create();
212 ASSERT_NE(NULL, format);
213 string widthStr = "width";
214 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
215 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
216 }
217
218 /**
219 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1400
220 * @tc.name : OH_VideoDecoder_Configure para error
221 * @tc.desc : function test
222 */
223 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_5100, TestSize.Level2)
224 {
225 OH_AVFormat *format = OH_AVFormat_Create();
226 ASSERT_NE(NULL, format);
227
228 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
229 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
230 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
231 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
232 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(NULL, format));
233 }
234
235 /**
236 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0600
237 * @tc.name : OH_VideoDecoder_Start para error
238 * @tc.desc : function test
239 */
240 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0600, TestSize.Level2)
241 {
242 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Start(NULL));
243 }
244
245 /**
246 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0700
247 * @tc.name : OH_VideoDecoder_Stop para error
248 * @tc.desc : function test
249 */
250 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0700, TestSize.Level2)
251 {
252 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Stop(NULL));
253 }
254
255 /**
256 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0800
257 * @tc.name : OH_VideoDecoder_Flush para error
258 * @tc.desc : function test
259 */
260 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0800, TestSize.Level2)
261 {
262 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Flush(NULL));
263 }
264
265 /**
266 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_0900
267 * @tc.name : OH_VideoDecoder_Reset para error
268 * @tc.desc : function test
269 */
270 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_0900, TestSize.Level2)
271 {
272 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Reset(NULL));
273 }
274
275 /**
276 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1000
277 * @tc.name : OH_VideoDecoder_GetOutputDescription para error
278 * @tc.desc : function test
279 */
280 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1000, TestSize.Level2)
281 {
282 ASSERT_EQ(NULL, OH_VideoDecoder_GetOutputDescription(NULL));
283 }
284
285 /**
286 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1100
287 * @tc.name : OH_VideoDecoder_SetParameter para error
288 * @tc.desc : function test
289 */
290 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1100, TestSize.Level2)
291 {
292 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
293 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(vdec_, NULL));
294 }
295
296 /**
297 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_4100
298 * @tc.name : OH_VideoDecoder_Prepare para error
299 * @tc.desc : function test
300 */
301 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_4100, TestSize.Level2)
302 {
303 OH_AVErrCode ret = AV_ERR_OK;
304 ret = OH_VideoDecoder_Prepare(nullptr);
305 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
306 }
307
308 /**
309 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1500
310 * @tc.name : OH_VideoDecoder_SetParameter para error
311 * @tc.desc : function test
312 */
313 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1500, TestSize.Level2)
314 {
315 OH_AVFormat *format = OH_AVFormat_Create();
316 ASSERT_NE(NULL, format);
317
318 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
319 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
320 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
321 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
322 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetParameter(NULL, format));
323 }
324
325 /**
326 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1200
327 * @tc.name : OH_VideoDecoder_SetSurface para error
328 * @tc.desc : function test
329 */
330 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1200, TestSize.Level2)
331 {
332 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
333 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_SetSurface(vdec_, NULL));
334 }
335
336 /**
337 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1300
338 * @tc.name : OH_VideoDecoder_CreateByName para correct
339 * @tc.desc : function test
340 */
341 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1300, TestSize.Level2)
342 {
343 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
344 }
345
346 /**
347 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1600
348 * @tc.name : OH_VideoDecoder_CreateByName para error
349 * @tc.desc : function test
350 */
351 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1600, TestSize.Level2)
352 {
353 vdec_ = OH_VideoDecoder_CreateByName(INVALID_CODEC_NAME.c_str());
354 ASSERT_EQ(NULL, vdec_);
355 }
356
357 /**
358 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1700
359 * @tc.name : OH_VideoDecoder_CreateByName para error
360 * @tc.desc : function test
361 */
362 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_1700, TestSize.Level2)
363 {
364 vdec_ = OH_VideoDecoder_CreateByMime(INVALID_CODEC_NAME.c_str());
365 ASSERT_EQ(NULL, vdec_);
366 }
367
368 /**
369 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_1700
370 * @tc.name : OH_VideoDecoder_IsValid para error
371 * @tc.desc : function test
372 */
373 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2200, TestSize.Level2)
374 {
375 bool isValid = false;
376 OH_AVErrCode ret = AV_ERR_OK;
377 ret = OH_VideoDecoder_IsValid(nullptr, &isValid);
378 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
379 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
380 ASSERT_NE(NULL, vdec_);
381 ret = OH_VideoDecoder_IsValid(vdec_, nullptr);
382 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
383 }
384
385 /**
386 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2500
387 * @tc.name : OH_VideoDecoder_RenderOutputData para error
388 * @tc.desc : function test
389 */
390 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2500, TestSize.Level2)
391 {
392 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_RenderOutputData(NULL, 0));
393 }
394
395 /**
396 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2600
397 * @tc.name : OH_VideoDecoder_RenderOutputData para error
398 * @tc.desc : function test
399 */
400 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2600, TestSize.Level2)
401 {
402 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
403 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_RenderOutputData(vdec_, 0));
404 }
405
406 /**
407 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2700
408 * @tc.name : OH_VideoDecoder_FreeOutputData para error
409 * @tc.desc : function test
410 */
411 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2700, TestSize.Level2)
412 {
413 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_FreeOutputData(NULL, 0));
414 }
415
416 /**
417 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2800
418 * @tc.name : OH_VideoDecoder_FreeOutputData para error
419 * @tc.desc : function test
420 */
421 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2800, TestSize.Level2)
422 {
423 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
424 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, 0));
425 }
426
427 /**
428 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_2900
429 * @tc.name : OH_VideoDecoder_FreeOutputData para error
430 * @tc.desc : function test
431 */
432 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_2900, TestSize.Level2)
433 {
434 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
435 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_FreeOutputData(vdec_, -1));
436 }
437
438 /**
439 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3000
440 * @tc.name : OH_VideoDecoder_PushInputData para error
441 * @tc.desc : function test
442 */
443 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3000, TestSize.Level2)
444 {
445 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
446
447 OH_AVCodecBufferAttr attr;
448 attr.pts = -1;
449 attr.size = -1;
450 attr.offset = -1;
451 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
452
453 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
454 }
455
456 /**
457 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3100
458 * @tc.name : OH_VideoDecoder_PushInputData para error
459 * @tc.desc : function test
460 */
461 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3100, TestSize.Level2)
462 {
463 OH_AVCodecBufferAttr attr;
464 attr.pts = 0;
465 attr.size = 0;
466 attr.offset = 0;
467 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
468
469 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, -1, attr));
470 }
471
472 /**
473 * @tc.number : VIDEO_HWDEC_ILLEGAL_PARA_3200
474 * @tc.name : OH_VideoDecoder_PushInputData para error
475 * @tc.desc : function test
476 */
477 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_ILLEGAL_PARA_3200, TestSize.Level2)
478 {
479 OH_AVCodecBufferAttr attr;
480 attr.pts = 0;
481 attr.size = 0;
482 attr.offset = 0;
483 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
484
485 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_PushInputData(NULL, 0, attr));
486 }
487
488 /**
489 * @tc.number : VIDEO_HWDEC_API_0100
490 * @tc.name : create create
491 * @tc.desc : function test
492 */
493 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0100, TestSize.Level2)
494 {
495 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
496 ASSERT_NE(vdec_, NULL);
497 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByName(g_codecName.c_str());
498 ASSERT_NE(vdec_2, NULL);
499 OH_VideoDecoder_Destroy(vdec_2);
500 vdec_2 = nullptr;
501 }
502
503 /**
504 * @tc.number : VIDEO_HWDEC_API_0200
505 * @tc.name : create configure configure
506 * @tc.desc : function test
507 */
508 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0200, TestSize.Level2)
509 {
510 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
511 ASSERT_NE(NULL, vdec_);
512
513 OH_AVFormat *format = OH_AVFormat_Create();
514 ASSERT_NE(NULL, format);
515
516 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
517 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
518 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
519 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
520
521 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
522 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Configure(vdec_, format));
523 }
524
525 /**
526 * @tc.number : VIDEO_HWDEC_API_0300
527 * @tc.name : create configure start start
528 * @tc.desc : function test
529 */
530 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0300, TestSize.Level2)
531 {
532 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
533 ASSERT_NE(NULL, vdec_);
534
535 OH_AVFormat *format = OH_AVFormat_Create();
536 ASSERT_NE(NULL, format);
537
538 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
539 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
540 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
541 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
542
543 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
544 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
545 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Start(vdec_));
546 }
547
548 /**
549 * @tc.number : VIDEO_HWDEC_API_0400
550 * @tc.name : create configure start stop stop
551 * @tc.desc : function test
552 */
553 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0400, TestSize.Level2)
554 {
555 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
556 ASSERT_NE(NULL, vdec_);
557
558 OH_AVFormat *format = OH_AVFormat_Create();
559 ASSERT_NE(NULL, format);
560
561 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
562 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
563 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
564 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
565
566 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
567 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
568 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
569 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Stop(vdec_));
570 }
571
572 /**
573 * @tc.number : VIDEO_HWDEC_API_0500
574 * @tc.name : create configure start stop reset reset
575 * @tc.desc : function test
576 */
577 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0500, TestSize.Level2)
578 {
579 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
580 ASSERT_NE(NULL, vdec_);
581
582 OH_AVFormat *format = OH_AVFormat_Create();
583 ASSERT_NE(NULL, format);
584
585 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
586 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
587 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
588 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
589
590 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
591 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
592 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
593 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
594 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
595 }
596
597 /**
598 * @tc.number : VIDEO_HWDEC_API_0600
599 * @tc.name : create configure start EOS EOS
600 * @tc.desc : function test
601 */
602 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0600, TestSize.Level2)
603 {
604 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
605 ASSERT_NE(NULL, vdec_);
606 OH_AVFormat *format = OH_AVFormat_Create();
607 ASSERT_NE(NULL, format);
608 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
609 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
610 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
611 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
612 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
613 OH_AVCodecAsyncCallback cb_;
614 cb_.onError = VdecError;
615 cb_.onStreamChanged = VdecFormatChanged;
616 cb_.onNeedInputData = VDecNeedInputData;
617 cb_.onNeedOutputData = VdecOutputDataReady;
618 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, static_cast<void *>(signal_)));
619 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
620 for (int i = 0; i < 2; i++) {
621 unique_lock<mutex> lock(signal_->inMutex_);
__anonbce3dab70302() 622 signal_->inCond_.wait(lock, []() { return signal_->inIdxQueue_.size() > 0; });
623 uint32_t index = signal_->inIdxQueue_.front();
624 OH_AVCodecBufferAttr attr;
625 attr.pts = 0;
626 attr.size = 0;
627 attr.offset = 0;
628 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
629 cout << "OH_VideoDecoder_PushInputData index:" << index << endl;
630 if (i == 0) {
631 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_PushInputData(vdec_, index, attr));
632 } else {
633 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_PushInputData(vdec_, 0, attr));
634 }
635 }
636 OH_VideoDecoder_Destroy(vdec_);
637 vdec_ = nullptr;
638 signal_->inIdxQueue_.pop();
639 }
640
641 /**
642 * @tc.number : VIDEO_HWDEC_API_0700
643 * @tc.name : create configure start flush flush
644 * @tc.desc : function test
645 */
646 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0700, TestSize.Level2)
647 {
648 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
649 ASSERT_NE(NULL, vdec_);
650
651 OH_AVFormat *format = OH_AVFormat_Create();
652 ASSERT_NE(NULL, format);
653
654 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
655 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
656 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
657 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
658
659 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
660 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
661 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
662 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_Flush(vdec_));
663 }
664
665 /**
666 * @tc.number : VIDEO_HWDEC_API_0800
667 * @tc.name : create configure start stop release release
668 * @tc.desc : function test
669 */
670 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0800, TestSize.Level2)
671 {
672 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
673 ASSERT_NE(NULL, vdec_);
674
675 OH_AVFormat *format = OH_AVFormat_Create();
676 ASSERT_NE(NULL, format);
677
678 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
679 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
680 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
681 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
682
683 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
684 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
685 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Stop(vdec_));
686 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
687 vdec_ = nullptr;
688 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Destroy(vdec_));
689 }
690
691 /**
692 * @tc.number : VIDEO_HWDEC_API_0900
693 * @tc.name : create create
694 * @tc.desc : function test
695 */
696 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_0900, TestSize.Level2)
697 {
698 vdec_ = OH_VideoDecoder_CreateByMime(CODEC_MIME.c_str());
699 ASSERT_NE(vdec_, NULL);
700 OH_AVCodec *vdec_2 = OH_VideoDecoder_CreateByMime(CODEC_MIME.c_str());
701 ASSERT_NE(vdec_2, NULL);
702 OH_VideoDecoder_Destroy(vdec_2);
703 vdec_2 = nullptr;
704 }
705
706 /**
707 * @tc.number : VIDEO_HWDEC_API_1000
708 * @tc.name : repeat OH_VideoDecoder_SetCallback
709 * @tc.desc : function test
710 */
711 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1000, TestSize.Level2)
712 {
713 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
714 OH_AVCodecAsyncCallback cb_;
715 cb_.onError = VdecError;
716 cb_.onStreamChanged = VdecFormatChanged;
717 cb_.onNeedInputData = VdecInputDataReady;
718 cb_.onNeedOutputData = VdecOutputDataReady;
719 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
720 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetCallback(vdec_, cb_, NULL));
721 }
722
723 /**
724 * @tc.number : VIDEO_HWDEC_API_1100
725 * @tc.name : repeat OH_VideoDecoder_GetOutputDescription
726 * @tc.desc : function test
727 */
728 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1100, TestSize.Level2)
729 {
730 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
731 OH_AVFormat *format = OH_VideoDecoder_GetOutputDescription(vdec_);
732 ASSERT_NE(NULL, format);
733 format = OH_VideoDecoder_GetOutputDescription(vdec_);
734 ASSERT_NE(NULL, format);
735 }
736
737 /**
738 * @tc.number : VIDEO_HWDEC_API_1200
739 * @tc.name : repeat OH_VideoDecoder_SetParameter
740 * @tc.desc : function test
741 */
742 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_API_1200, TestSize.Level2)
743 {
744 vdec_ = OH_VideoDecoder_CreateByName(g_codecName.c_str());
745 ASSERT_NE(NULL, vdec_);
746
747 OH_AVFormat *format = OH_AVFormat_Create();
748 ASSERT_NE(NULL, format);
749
750 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
751 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
752 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
753 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
754
755 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
756 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoDecoder_SetParameter(vdec_, format));
757 }
758
759 /**
760 * @tc.number : VIDEO_HWDEC_CAP_API_0100
761 * @tc.name : OH_AVCodec_GetCapability
762 * @tc.desc : function test
763 */
764 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0100, TestSize.Level2)
765 {
766 cap = OH_AVCodec_GetCapability(CODEC_MIME.c_str(), false);
767 ASSERT_NE(cap, nullptr);
768 }
769
770 /**
771 * @tc.number : VIDEO_HWDEC_CAP_API_0200
772 * @tc.name : OH_AVCodec_GetCapability
773 * @tc.desc : function test
774 */
775 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0200, TestSize.Level2)
776 {
777 cap = OH_AVCodec_GetCapability(nullptr, false);
778 ASSERT_EQ(cap, nullptr);
779 }
780
781 /**
782 * @tc.number : VIDEO_HWDEC_CAP_API_0300
783 * @tc.name : OH_AVCodec_GetCapability
784 * @tc.desc : function test
785 */
786 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0300, TestSize.Level2)
787 {
788 cap = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
789 ASSERT_NE(cap, nullptr);
790 }
791
792 /**
793 * @tc.number : VIDEO_HWDEC_CAP_API_0400
794 * @tc.name : OH_AVCodec_GetCapability
795 * @tc.desc : function test
796 */
797 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0400, TestSize.Level2)
798 {
799 cap = OH_AVCodec_GetCapabilityByCategory(nullptr, false, HARDWARE);
800 ASSERT_EQ(cap, nullptr);
801 }
802
803 /**
804 * @tc.number : VIDEO_HWDEC_CAP_API_0500
805 * @tc.name : OH_AVCodec_GetCapability
806 * @tc.desc : function test
807 */
808 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0500, TestSize.Level2)
809 {
810 cap = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
811 ASSERT_NE(cap, nullptr);
812 ASSERT_TRUE(OH_AVCapability_IsHardware(cap));
813 }
814
815 /**
816 * @tc.number : VIDEO_HWDEC_CAP_API_0600
817 * @tc.name : OH_AVCodec_GetCapability
818 * @tc.desc : function test
819 */
820 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0600, TestSize.Level2)
821 {
822 ASSERT_FALSE(OH_AVCapability_IsHardware(nullptr));
823 }
824
825 /**
826 * @tc.number : VIDEO_HWDEC_CAP_API_0700
827 * @tc.name : OH_AVCodec_GetCapability
828 * @tc.desc : function test
829 */
830 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0700, TestSize.Level2)
831 {
832 ASSERT_EQ(0, OH_AVCapability_GetMaxSupportedInstances(nullptr));
833 }
834
835 /**
836 * @tc.number : VIDEO_HWDEC_CAP_API_0800
837 * @tc.name : OH_AVCodec_GetCapability
838 * @tc.desc : function test
839 */
840 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0800, TestSize.Level2)
841 {
842 cap = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
843 ASSERT_NE(cap, nullptr);
844 string codec_name = OH_AVCapability_GetName(cap);
845 if (codec_name == "OMX.hisi.video.decoder.avc") {
846 ASSERT_EQ(16, OH_AVCapability_GetMaxSupportedInstances(cap));
847 } else {
848 ASSERT_EQ(6, OH_AVCapability_GetMaxSupportedInstances(cap));
849 }
850 }
851
852 /**
853 * @tc.number : VIDEO_HWDEC_CAP_API_0900
854 * @tc.name : OH_AVCodec_GetCapability
855 * @tc.desc : function test
856 */
857 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_0900, TestSize.Level2)
858 {
859 cap = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
860 ASSERT_NE(cap, nullptr);
861 ASSERT_EQ(g_codecName, OH_AVCapability_GetName(cap));
862 }
863
864 /**
865 * @tc.number : VIDEO_HWDEC_CAP_API_1000
866 * @tc.name : OH_AVCodec_GetCapability
867 * @tc.desc : function test
868 */
869 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_1000, TestSize.Level2)
870 {
871 const char *name = OH_AVCapability_GetName(nullptr);
872 ASSERT_NE(name, nullptr);
873 ASSERT_EQ(strlen(name), 0);
874 }
875
876 /**
877 * @tc.number : VIDEO_HWDEC_CAP_API_3100
878 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
879 * @tc.desc : api test
880 */
881 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3100, TestSize.Level2)
882 {
883 OH_AVErrCode ret = AV_ERR_OK;
884 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
885 ASSERT_NE(nullptr, capability);
886 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
887 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
888 }
889
890 /**
891 * @tc.number : VIDEO_HWDEC_CAP_API_3200
892 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
893 * @tc.desc : api test
894 */
895 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3200, TestSize.Level2)
896 {
897 OH_AVErrCode ret = AV_ERR_OK;
898 int32_t alignment = 0;
899 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
900 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
901 }
902
903 /**
904 * @tc.number : VIDEO_HWDEC_CAP_API_3300
905 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
906 * @tc.desc : api test
907 */
908 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3300, TestSize.Level2)
909 {
910 OH_AVErrCode ret = AV_ERR_OK;
911 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
912 ASSERT_NE(nullptr, capability);
913 int32_t alignment = 0;
914 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
915 cout << "WidthAlignment " << alignment << endl;
916 ASSERT_EQ(AV_ERR_OK, ret);
917 ASSERT_EQ(alignment >= 0, true);
918 }
919
920 /**
921 * @tc.number : VIDEO_HWDEC_CAP_API_3400
922 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
923 * @tc.desc : api test
924 */
925 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3400, TestSize.Level2)
926 {
927 OH_AVErrCode ret = AV_ERR_OK;
928 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
929 ASSERT_NE(nullptr, capability);
930 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
931 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
932 }
933
934 /**
935 * @tc.number : VIDEO_HWDEC_CAP_API_3500
936 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
937 * @tc.desc : api test
938 */
939 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3500, TestSize.Level2)
940 {
941 OH_AVErrCode ret = AV_ERR_OK;
942 int32_t alignment = 0;
943 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
944 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
945 }
946
947 /**
948 * @tc.number : VIDEO_HWDEC_CAP_API_3600
949 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
950 * @tc.desc : api test
951 */
952 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3600, TestSize.Level2)
953 {
954 OH_AVErrCode ret = AV_ERR_OK;
955 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
956 ASSERT_NE(nullptr, capability);
957 int32_t alignment = 0;
958 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
959 cout << "HeightAlignment " << alignment << endl;
960 ASSERT_EQ(AV_ERR_OK, ret);
961 ASSERT_EQ(alignment >= 0, true);
962 }
963
964 /**
965 * @tc.number : VIDEO_HWDEC_CAP_API_3700
966 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
967 * @tc.desc : api test
968 */
969 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3700, TestSize.Level2)
970 {
971 OH_AVErrCode ret = AV_ERR_OK;
972 OH_AVRange range;
973 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
974 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
975 ASSERT_NE(nullptr, capability);
976 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, 1080, &range);
977 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
978 }
979
980 /**
981 * @tc.number : VIDEO_HWDEC_CAP_API_3800
982 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
983 * @tc.desc : api test
984 */
985 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3800, TestSize.Level2)
986 {
987 OH_AVErrCode ret = AV_ERR_OK;
988 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
989 ASSERT_NE(nullptr, capability);
990 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 1080, nullptr);
991 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
992 }
993
994 /**
995 * @tc.number : VIDEO_HWDEC_CAP_API_3900
996 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
997 * @tc.desc : api test
998 */
999 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_3900, TestSize.Level2)
1000 {
1001 OH_AVErrCode ret = AV_ERR_OK;
1002 OH_AVRange range;
1003 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1004 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1005 ASSERT_NE(nullptr, capability);
1006 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
1007 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1008 }
1009
1010 /**
1011 * @tc.number : VIDEO_HWDEC_CAP_API_4000
1012 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
1013 * @tc.desc : api test
1014 */
1015 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4000, TestSize.Level2)
1016 {
1017 OH_AVErrCode ret = AV_ERR_OK;
1018 OH_AVRange range;
1019 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1020 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1021 ASSERT_NE(nullptr, capability);
1022 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 1080, &range);
1023 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1024 ASSERT_EQ(AV_ERR_OK, ret);
1025 ASSERT_EQ(true, (range.minVal >= 0));
1026 ASSERT_EQ(true, (range.maxVal > 0));
1027 }
1028
1029 /**
1030 * @tc.number : VIDEO_HWDEC_CAP_API_4100
1031 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1032 * @tc.desc : api test
1033 */
1034 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4100, TestSize.Level2)
1035 {
1036 OH_AVErrCode ret = AV_ERR_OK;
1037 OH_AVRange range;
1038 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1039 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1040 ASSERT_NE(nullptr, capability);
1041 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, 1920, &range);
1042 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1043 }
1044
1045 /**
1046 * @tc.number : VIDEO_HWDEC_CAP_API_4200
1047 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1048 * @tc.desc : api test
1049 */
1050 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4200, TestSize.Level2)
1051 {
1052 OH_AVErrCode ret = AV_ERR_OK;
1053 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1054 ASSERT_NE(nullptr, capability);
1055 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 1920, nullptr);
1056 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1057 }
1058
1059 /**
1060 * @tc.number : VIDEO_HWDEC_CAP_API_4300
1061 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1062 * @tc.desc : api test
1063 */
1064 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4300, TestSize.Level2)
1065 {
1066 OH_AVErrCode ret = AV_ERR_OK;
1067 OH_AVRange range;
1068 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1069 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1070 ASSERT_NE(nullptr, capability);
1071 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1072 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1073 }
1074
1075 /**
1076 * @tc.number : VIDEO_HWDEC_CAP_API_4400
1077 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1078 * @tc.desc : api test
1079 */
1080 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4400, TestSize.Level2)
1081 {
1082 OH_AVErrCode ret = AV_ERR_OK;
1083 OH_AVRange range;
1084 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1085 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1086 ASSERT_NE(nullptr, capability);
1087 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 1920, &range);
1088 ASSERT_EQ(AV_ERR_OK, ret);
1089 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1090 ASSERT_EQ(true, (range.minVal >= 0));
1091 ASSERT_EQ(true, (range.maxVal > 0));
1092 }
1093
1094 /**
1095 * @tc.number : VIDEO_HWDEC_CAP_API_4500
1096 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1097 * @tc.desc : api test
1098 */
1099 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4500, TestSize.Level2)
1100 {
1101 OH_AVErrCode ret = AV_ERR_OK;
1102 OH_AVRange range;
1103 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1104 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1105 }
1106
1107 /**
1108 * @tc.number : VIDEO_HWDEC_CAP_API_4600
1109 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1110 * @tc.desc : api test
1111 */
1112 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4600, TestSize.Level2)
1113 {
1114 OH_AVErrCode ret = AV_ERR_OK;
1115 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1116 ASSERT_NE(nullptr, capability);
1117 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1118 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1119 }
1120
1121 /**
1122 * @tc.number : VIDEO_HWDEC_CAP_API_4700
1123 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1124 * @tc.desc : api test
1125 */
1126 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4700, TestSize.Level2)
1127 {
1128 OH_AVErrCode ret = AV_ERR_OK;
1129 OH_AVRange range;
1130 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1131 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1132 ASSERT_NE(nullptr, capability);
1133 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1134 ASSERT_EQ(AV_ERR_OK, ret);
1135 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1136 ASSERT_EQ(true, (range.minVal >= 0));
1137 ASSERT_EQ(true, (range.maxVal > 0));
1138 }
1139
1140 /**
1141 * @tc.number : VIDEO_HWDEC_CAP_API_4800
1142 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1143 * @tc.desc : api test
1144 */
1145 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4800, TestSize.Level2)
1146 {
1147 OH_AVErrCode ret = AV_ERR_OK;
1148 OH_AVRange range;
1149 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1150 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1151 }
1152
1153 /**
1154 * @tc.number : VIDEO_HWDEC_CAP_API_4900
1155 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1156 * @tc.desc : api test
1157 */
1158 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_4900, TestSize.Level2)
1159 {
1160 OH_AVErrCode ret = AV_ERR_OK;
1161 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1162 ASSERT_NE(nullptr, capability);
1163 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1164 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1165 }
1166
1167 /**
1168 * @tc.number : VIDEO_HWDEC_CAP_API_5000
1169 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1170 * @tc.desc : api test
1171 */
1172 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5000, TestSize.Level2)
1173 {
1174 OH_AVErrCode ret = AV_ERR_OK;
1175 OH_AVRange range;
1176 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1177 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1178 ASSERT_NE(nullptr, capability);
1179 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
1180 ASSERT_EQ(AV_ERR_OK, ret);
1181 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1182 ASSERT_EQ(true, (range.minVal >= 0));
1183 ASSERT_EQ(true, (range.maxVal > 0));
1184 }
1185
1186 /**
1187 * @tc.number : VIDEO_HWDEC_CAP_API_5100
1188 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1189 * @tc.desc : api test
1190 */
1191 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5100, TestSize.Level2)
1192 {
1193 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1194 ASSERT_NE(nullptr, capability);
1195 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, 1080));
1196 }
1197
1198 /**
1199 * @tc.number : VIDEO_HWDEC_CAP_API_5200
1200 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1201 * @tc.desc : api test
1202 */
1203 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5200, TestSize.Level2)
1204 {
1205 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1206 ASSERT_NE(nullptr, capability);
1207 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 1920, 0));
1208 }
1209 /**
1210 * @tc.number : VIDEO_HWDEC_CAP_API_5300
1211 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1212 * @tc.desc : api test
1213 */
1214 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5300, TestSize.Level2)
1215 {
1216 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, 1920, 1080));
1217 }
1218 /**
1219 * @tc.number : VIDEO_HWDEC_CAP_API_9400
1220 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1221 * @tc.desc : api test
1222 */
1223 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_9400, TestSize.Level2)
1224 {
1225 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1226 ASSERT_NE(nullptr, capability);
1227 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 7680, 4320));
1228 }
1229 /**
1230 * @tc.number : VIDEO_HWDEC_CAP_API_5400
1231 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1232 * @tc.desc : api test
1233 */
1234 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5400, TestSize.Level2)
1235 {
1236 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1237 ASSERT_NE(nullptr, capability);
1238 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, 1920, 1080));
1239 }
1240
1241 /**
1242 * @tc.number : VIDEO_HWDEC_CAP_API_5500
1243 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1244 * @tc.desc : api test
1245 */
1246 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5500, TestSize.Level2)
1247 {
1248 OH_AVErrCode ret = AV_ERR_OK;
1249 OH_AVRange range;
1250 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1251 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1252 }
1253
1254 /**
1255 * @tc.number : VIDEO_HWDEC_CAP_API_5600
1256 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1257 * @tc.desc : api test
1258 */
1259 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5600, TestSize.Level2)
1260 {
1261 OH_AVErrCode ret = AV_ERR_OK;
1262 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1263 ASSERT_NE(nullptr, capability);
1264 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1265 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1266 }
1267
1268 /**
1269 * @tc.number : VIDEO_HWDEC_CAP_API_5700
1270 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1271 * @tc.desc : api test
1272 */
1273 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5700, TestSize.Level2)
1274 {
1275 OH_AVErrCode ret = AV_ERR_OK;
1276 OH_AVRange range;
1277 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1278 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1279 ASSERT_NE(nullptr, capability);
1280 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1281 ASSERT_EQ(AV_ERR_OK, ret);
1282 ASSERT_EQ(true, (range.minVal >= 0));
1283 ASSERT_EQ(true, (range.maxVal > 0));
1284 }
1285
1286 /**
1287 * @tc.number : VIDEO_HWDEC_CAP_API_5800
1288 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1289 * @tc.desc : api test
1290 */
1291 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5800, TestSize.Level2)
1292 {
1293 OH_AVErrCode ret = AV_ERR_OK;
1294 OH_AVRange range;
1295 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, 1920, 1080, &range);
1296 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1297 }
1298
1299 /**
1300 * @tc.number : VIDEO_HWDEC_CAP_API_5900
1301 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1302 * @tc.desc : api test
1303 */
1304 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_5900, TestSize.Level2)
1305 {
1306 OH_AVErrCode ret = AV_ERR_OK;
1307 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1308 ASSERT_NE(nullptr, capability);
1309 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1920, 1080, nullptr);
1310 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1311 }
1312
1313 /**
1314 * @tc.number : VIDEO_HWDEC_CAP_API_6000
1315 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1316 * @tc.desc : api test
1317 */
1318 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6000, TestSize.Level2)
1319 {
1320 OH_AVErrCode ret = AV_ERR_OK;
1321 OH_AVRange range;
1322 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1323 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1324 ASSERT_NE(nullptr, capability);
1325 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, 1080, &range);
1326 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1327 }
1328
1329 /**
1330 * @tc.number : VIDEO_HWDEC_CAP_API_6100
1331 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1332 * @tc.desc : api test
1333 */
1334 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6100, TestSize.Level2)
1335 {
1336 OH_AVErrCode ret = AV_ERR_OK;
1337 OH_AVRange range;
1338 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1339 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1340 ASSERT_NE(nullptr, capability);
1341 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1920, 0, &range);
1342 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1343 }
1344
1345 /**
1346 * @tc.number : VIDEO_HWDEC_CAP_API_6200
1347 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1348 * @tc.desc : api test
1349 */
1350 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6200, TestSize.Level2)
1351 {
1352 OH_AVErrCode ret = AV_ERR_OK;
1353 OH_AVRange range;
1354 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1355 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1356 ASSERT_NE(nullptr, capability);
1357 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1280, 720, &range);
1358 ASSERT_EQ(AV_ERR_OK, ret);
1359 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1360 ASSERT_EQ(true, (range.minVal >= 0));
1361 ASSERT_EQ(true, (range.maxVal > 0));
1362
1363 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1920, 1080, &range);
1364 ASSERT_EQ(AV_ERR_OK, ret);
1365 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1366 ASSERT_EQ(true, (range.minVal >= 0));
1367 ASSERT_EQ(true, (range.maxVal > 0));
1368 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 3840, 2160, &range);
1369 ASSERT_EQ(AV_ERR_OK, ret);
1370 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1371 ASSERT_EQ(true, (range.minVal >= 0));
1372 ASSERT_EQ(true, (range.maxVal > 0));
1373 }
1374
1375 /**
1376 * @tc.number : VIDEO_HWDEC_CAP_API_6300
1377 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1378 * @tc.desc : api test
1379 */
1380 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6300, TestSize.Level2)
1381 {
1382 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1383 ASSERT_NE(nullptr, capability);
1384 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, 1080, 30));
1385 }
1386
1387 /**
1388 * @tc.number : VIDEO_HWDEC_CAP_API_6400
1389 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1390 * @tc.desc : api test
1391 */
1392 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6400, TestSize.Level2)
1393 {
1394 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1395 ASSERT_NE(nullptr, capability);
1396 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 1920, 0, 30));
1397 }
1398
1399 /**
1400 * @tc.number : VIDEO_HWDEC_CAP_API_6500
1401 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1402 * @tc.desc : api test
1403 */
1404 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6500, TestSize.Level2)
1405 {
1406 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1407 ASSERT_NE(nullptr, capability);
1408 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 1920, 1080, 0));
1409 }
1410
1411 /**
1412 * @tc.number : VIDEO_HWDEC_CAP_API_6600
1413 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1414 * @tc.desc : api test
1415 */
1416 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6600, TestSize.Level2)
1417 {
1418 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, 1920, 1080, 30));
1419 }
1420
1421 /**
1422 * @tc.number : VIDEO_HWDEC_CAP_API_6700
1423 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1424 * @tc.desc : api test
1425 */
1426 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6700, TestSize.Level2)
1427 {
1428 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1429 ASSERT_NE(nullptr, capability);
1430 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 1920, 1080, 30));
1431 }
1432
1433 /**
1434 * @tc.number : VIDEO_HWDEC_CAP_API_6800
1435 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1436 * @tc.desc : api test
1437 */
1438 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6800, TestSize.Level2)
1439 {
1440 OH_AVErrCode ret = AV_ERR_OK;
1441 const int32_t *pixelFormat = nullptr;
1442 uint32_t pixelFormatNum = 0;
1443 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1444 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1445 }
1446
1447 /**
1448 * @tc.number : VIDEO_HWDEC_CAP_API_6900
1449 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1450 * @tc.desc : api test
1451 */
1452 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_6900, TestSize.Level2)
1453 {
1454 OH_AVErrCode ret = AV_ERR_OK;
1455 uint32_t pixelFormatNum = 0;
1456 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1457 ASSERT_NE(nullptr, capability);
1458 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1459 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1460 }
1461
1462 /**
1463 * @tc.number : VIDEO_HWDEC_CAP_API_7000
1464 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1465 * @tc.desc : api test
1466 */
1467 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7000, TestSize.Level2)
1468 {
1469 OH_AVErrCode ret = AV_ERR_OK;
1470 const int32_t *pixelFormat = nullptr;
1471 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1472 ASSERT_NE(nullptr, capability);
1473 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1474 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1475 }
1476
1477 /**
1478 * @tc.number : VIDEO_HWDEC_CAP_API_7100
1479 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1480 * @tc.desc : api test
1481 */
1482 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7100, TestSize.Level2)
1483 {
1484 OH_AVErrCode ret = AV_ERR_OK;
1485 const int32_t *pixelFormat = nullptr;
1486 uint32_t pixelFormatNum = 0;
1487 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1488 ASSERT_NE(nullptr, capability);
1489 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1490 for (int i = 0; i < pixelFormatNum; i++)
1491 cout << pixelFormat[i] << " ";
1492 ASSERT_EQ(AV_ERR_OK, ret);
1493 cout << endl;
1494 }
1495
1496 /**
1497 * @tc.number : VIDEO_HWDEC_CAP_API_7200
1498 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1499 * @tc.desc : api test
1500 */
1501 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7200, TestSize.Level2)
1502 {
1503 OH_AVErrCode ret = AV_ERR_OK;
1504 const int32_t *profiles = nullptr;
1505 uint32_t profileNum = 0;
1506 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
1507 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1508 }
1509
1510 /**
1511 * @tc.number : VIDEO_HWDEC_CAP_API_7300
1512 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1513 * @tc.desc : api test
1514 */
1515 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7300, TestSize.Level2)
1516 {
1517 OH_AVErrCode ret = AV_ERR_OK;
1518 uint32_t profileNum = 0;
1519 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1520 ASSERT_NE(nullptr, capability);
1521 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
1522 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1523 }
1524
1525 /**
1526 * @tc.number : VIDEO_HWDEC_CAP_API_7400
1527 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1528 * @tc.desc : api test
1529 */
1530 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7400, TestSize.Level2)
1531 {
1532 OH_AVErrCode ret = AV_ERR_OK;
1533 const int32_t *profiles = nullptr;
1534 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1535 ASSERT_NE(nullptr, capability);
1536 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
1537 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1538 }
1539
1540 /**
1541 * @tc.number : VIDEO_HWDEC_CAP_API_7500
1542 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1543 * @tc.desc : api test
1544 */
1545 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7500, TestSize.Level2)
1546 {
1547 OH_AVErrCode ret = AV_ERR_OK;
1548 const int32_t *profiles = nullptr;
1549 uint32_t profileNum = 0;
1550 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1551 ASSERT_NE(nullptr, capability);
1552 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1553 ASSERT_EQ(AV_ERR_OK, ret);
1554 for (int i = 0; i < profileNum; i++)
1555 cout << profiles[i] << " ";
1556 cout << endl;
1557 }
1558
1559 /**
1560 * @tc.number : VIDEO_HWDEC_CAP_API_7600
1561 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1562 * @tc.desc : api test
1563 */
1564 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7600, TestSize.Level2)
1565 {
1566 OH_AVErrCode ret = AV_ERR_OK;
1567 const int32_t *levels = nullptr;
1568 uint32_t levelNum = 0;
1569 ret = OH_AVCapability_GetSupportedLevelsForProfile(nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
1570 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1571 }
1572
1573 /**
1574 * @tc.number : VIDEO_HWDEC_CAP_API_7700
1575 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1576 * @tc.desc : api test
1577 */
1578 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7700, TestSize.Level2)
1579 {
1580 OH_AVErrCode ret = AV_ERR_OK;
1581 const int32_t *levels = nullptr;
1582 uint32_t levelNum = 0;
1583 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1584 ASSERT_NE(nullptr, capability);
1585 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
1586 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1587 }
1588
1589 /**
1590 * @tc.number : VIDEO_HWDEC_CAP_API_7800
1591 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1592 * @tc.desc : api test
1593 */
1594 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7800, TestSize.Level2)
1595 {
1596 OH_AVErrCode ret = AV_ERR_OK;
1597 uint32_t levelNum = 0;
1598 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1599 ASSERT_NE(nullptr, capability);
1600 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
1601 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1602 }
1603
1604 /**
1605 * @tc.number : VIDEO_HWDEC_CAP_API_7900
1606 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1607 * @tc.desc : api test
1608 */
1609 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_7900, TestSize.Level2)
1610 {
1611 OH_AVErrCode ret = AV_ERR_OK;
1612 const int32_t *levels = nullptr;
1613 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1614 ASSERT_NE(nullptr, capability);
1615 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, nullptr);
1616 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1617 }
1618
1619 /**
1620 * @tc.number : VIDEO_HWDEC_CAP_API_8000
1621 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1622 * @tc.desc : api test
1623 */
1624 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8000, TestSize.Level2)
1625 {
1626 OH_AVErrCode ret = AV_ERR_OK;
1627 const int32_t *levels = nullptr;
1628 uint32_t levelNum = 0;
1629 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1630 ASSERT_NE(nullptr, capability);
1631 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, &levelNum);
1632 ASSERT_EQ(AV_ERR_OK, ret);
1633 for (int i = 0; i < levelNum; i++)
1634 cout << levels[i] << " ";
1635 cout << endl;
1636 }
1637
1638 /**
1639 * @tc.number : VIDEO_HWDEC_CAP_API_8100
1640 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1641 * @tc.desc : api test
1642 */
1643 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8100, TestSize.Level2)
1644 {
1645 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(nullptr, AVC_PROFILE_BASELINE, 1));
1646 }
1647
1648 /**
1649 * @tc.number : VIDEO_HWDEC_CAP_API_8200
1650 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1651 * @tc.desc : api test
1652 */
1653 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8200, TestSize.Level2)
1654 {
1655 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1656 ASSERT_NE(nullptr, capability);
1657 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
1658 }
1659
1660 /**
1661 * @tc.number : VIDEO_HWDEC_CAP_API_8300
1662 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1663 * @tc.desc : api test
1664 */
1665 HWTEST_F(HwdecApiNdkTest, VIDEO_HWDEC_CAP_API_8300, TestSize.Level2)
1666 {
1667 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME.c_str(), false, HARDWARE);
1668 ASSERT_NE(nullptr, capability);
1669 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
1670 }
1671 } // namespace