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 #include <iostream>
16 #include <cstdio>
17 #include <string>
18
19 #include "gtest/gtest.h"
20 #include "native_avcodec_base.h"
21 #include "native_avformat.h"
22 #include "native_avcodec_videoencoder.h"
23 #include "videoenc_ndk_sample.h"
24 #include "native_avcapability.h"
25 using namespace std;
26 using namespace OHOS;
27 using namespace OHOS::Media;
28 using namespace testing::ext;
29 namespace {
30 OH_AVCodec *venc_ = NULL;
31 constexpr uint32_t DEFAULT_WIDTH = 1920;
32 constexpr uint32_t DEFAULT_HEIGHT = 1080;
33 const char *codecMime = "video/avc";
34 constexpr uint32_t CODEC_NAME_SIZE = 128;
35 char g_codecName[CODEC_NAME_SIZE] = {};
36 OH_AVCapability *cap = nullptr;
37 OHOS::Media::VEncSignal *signal_ = nullptr;
38 OH_AVFormat *format;
onError(OH_AVCodec * codec,int32_t errorCode,void * userData)39 void onError(OH_AVCodec *codec, int32_t errorCode, void *userData)
40 {
41 cout << "Error errorCode=" << errorCode << endl;
42 };
43
onStreamChanged(OH_AVCodec * codec,OH_AVFormat * fmt,void * userData)44 void onStreamChanged(OH_AVCodec *codec, OH_AVFormat *fmt, void *userData)
45 {
46 cout << "stream Changed" << endl;
47 };
48
onNeedInputData(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,void * userData)49 void onNeedInputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, void *userData)
50 {
51 VEncSignal *signal = static_cast<VEncSignal *>(userData);
52 if (signal == nullptr) {
53 return;
54 }
55 unique_lock<mutex> lock(signal->inMutex_);
56 signal->inIdxQueue_.push(index);
57 signal->inBufferQueue_.push(data);
58 signal->inCond_.notify_all();
59 cout << "need input data" << endl;
60 };
61
onNewOutputData(OH_AVCodec * codec,uint32_t index,OH_AVMemory * data,OH_AVCodecBufferAttr * attr,void * userData)62 void onNewOutputData(OH_AVCodec *codec, uint32_t index, OH_AVMemory *data, OH_AVCodecBufferAttr *attr, void *userData)
63 {
64 cout << "output data" << endl;
65 VEncSignal *signal = static_cast<VEncSignal *>(userData);
66 if (signal == nullptr) {
67 return;
68 }
69 unique_lock<mutex> lock(signal->outMutex_);
70 signal->outIdxQueue_.push(index);
71 signal->attrQueue_.push(*attr);
72 signal->outBufferQueue_.push(data);
73 signal->outCond_.notify_all();
74 };
75 } // namespace
76
77 namespace OHOS {
78 namespace Media {
79 class HwEncApiNdkTest : public testing::Test {
80 public:
81 // SetUpTestCase: Called before all test cases
82 static void SetUpTestCase(void);
83 // TearDownTestCase: Called after all test case
84 static void TearDownTestCase(void);
85 // SetUp: Called before each test cases
86 void SetUp(void);
87 // TearDown: Called after each test cases
88 void TearDown(void);
89 };
90
SetUpTestCase()91 void HwEncApiNdkTest::SetUpTestCase()
92 {
93 cap = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
94 const char *TMP_CODEC_NAME = OH_AVCapability_GetName(cap);
95 if (memcpy_s(g_codecName, sizeof(g_codecName), TMP_CODEC_NAME, strlen(TMP_CODEC_NAME)) != 0) {
96 cout << "memcpy failed" << endl;
97 }
98 cout << "codecname: " << g_codecName << endl;
99 }
TearDownTestCase()100 void HwEncApiNdkTest::TearDownTestCase() {}
SetUp()101 void HwEncApiNdkTest::SetUp()
102 {
103 signal_ = new VEncSignal();
104 }
TearDown()105 void HwEncApiNdkTest::TearDown()
106 {
107 if (format != nullptr) {
108 OH_AVFormat_Destroy(format);
109 format = nullptr;
110 }
111 if (venc_ != NULL) {
112 OH_VideoEncoder_Destroy(venc_);
113 venc_ = nullptr;
114 }
115 if (signal_) {
116 delete signal_;
117 signal_ = nullptr;
118 }
119 }
120 } // namespace Media
121 } // namespace OHOS
122
123 namespace {
124 /**
125 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0100
126 * @tc.name : OH_VideoEncoder_CreateByMime para1 error
127 * @tc.desc : api test
128 */
129 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0100, TestSize.Level2)
130 {
131 venc_ = OH_VideoEncoder_CreateByMime(nullptr);
132 ASSERT_EQ(nullptr, venc_);
133 }
134
135 /**
136 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0200
137 * @tc.name : OH_VideoEncoder_CreateByMime para2 error
138 * @tc.desc : api test
139 */
140 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0200, TestSize.Level2)
141 {
142 venc_ = OH_VideoEncoder_CreateByMime("");
143 ASSERT_EQ(nullptr, venc_);
144 }
145
146 /**
147 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0300
148 * @tc.name : OH_VideoEncoder_CreateByMime para error
149 * @tc.desc : api test
150 */
151 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0300, TestSize.Level2)
152 {
153 venc_ = OH_VideoEncoder_CreateByName(nullptr);
154 ASSERT_EQ(nullptr, venc_);
155 }
156
157 /**
158 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0400
159 * @tc.name : OH_VideoEncoder_CreateByMime para error
160 * @tc.desc : api test
161 */
162 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0400, TestSize.Level2)
163 {
164 venc_ = OH_VideoEncoder_CreateByName("");
165 ASSERT_EQ(nullptr, venc_);
166 }
167
168 /**
169 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0500
170 * @tc.name : OH_VideoEncoder_CreateByMime para error
171 * @tc.desc : api test
172 */
173 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0500, TestSize.Level2)
174 {
175 OH_AVErrCode ret = AV_ERR_OK;
176 ret = OH_VideoEncoder_Destroy(nullptr);
177 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
178 }
179
180 /**
181 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0600
182 * @tc.name : OH_VideoEncoder_SetCallback para error
183 * @tc.desc : api test
184 */
185 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0600, TestSize.Level2)
186 {
187 OH_AVCodecAsyncCallback cb_;
188 cb_.onError = onError;
189 cb_.onStreamChanged = onStreamChanged;
190 cb_.onNeedInputData = onNeedInputData;
191 cb_.onNeedOutputData = onNewOutputData;
192
193 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_SetCallback(NULL, cb_, static_cast<void *>(signal_)));
194 }
195
196 /**
197 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0700
198 * @tc.name : OH_VideoEncoder_SetCallback para error
199 * @tc.desc : api test
200 */
201 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0700, TestSize.Level2)
202 {
203 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
204 ASSERT_NE(NULL, venc_);
205
206 OH_AVCodecAsyncCallback cb2_;
207 cb2_.onError = NULL;
208 cb2_.onStreamChanged = NULL;
209 cb2_.onNeedInputData = NULL;
210 cb2_.onNeedOutputData = NULL;
211 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb2_, static_cast<void *>(signal_)));
212 }
213
214 /**
215 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0800
216 * @tc.name : OH_VideoEncoder_SetCallback para error
217 * @tc.desc : api test
218 */
219 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0800, TestSize.Level2)
220 {
221 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
222 OH_AVCodecAsyncCallback cb_;
223 cb_.onError = onError;
224 cb_.onStreamChanged = onStreamChanged;
225 cb_.onNeedInputData = onNeedInputData;
226 cb_.onNeedOutputData = onNewOutputData;
227 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, NULL));
228 }
229
230 /**
231 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_0900
232 * @tc.name : OH_VideoEncoder_Configure para error
233 * @tc.desc : api test
234 */
235 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_0900, TestSize.Level2)
236 {
237 OH_AVErrCode ret = AV_ERR_OK;
238 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
239 ASSERT_NE(nullptr, venc_);
240 ret = OH_VideoEncoder_Configure(venc_, nullptr);
241 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
242 }
243
244 /**
245 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1100
246 * @tc.name : OH_VideoEncoder_Configure para not enough
247 * @tc.desc : api test
248 */
249 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1100, TestSize.Level2)
250 {
251 OH_AVErrCode ret = AV_ERR_OK;
252 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
253 ASSERT_NE(nullptr, venc_);
254 format = OH_AVFormat_Create();
255 ASSERT_NE(nullptr, format);
256 OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 100000);
257 ret = OH_VideoEncoder_Configure(venc_, format);
258 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
259 }
260
261 /**
262 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1400
263 * @tc.name : OH_VideoEncoder_Start para error
264 * @tc.desc : api test
265 */
266 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1400, TestSize.Level2)
267 {
268 OH_AVErrCode ret = AV_ERR_OK;
269 ret = OH_VideoEncoder_Start(nullptr);
270 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
271 }
272
273 /**
274 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1500
275 * @tc.name : OH_VideoEncoder_Stop para error
276 * @tc.desc : api test
277 */
278 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1500, TestSize.Level2)
279 {
280 OH_AVErrCode ret = AV_ERR_OK;
281 ret = OH_VideoEncoder_Stop(nullptr);
282 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
283 }
284
285 /**
286 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1600
287 * @tc.name : OH_VideoEncoder_Flush para error
288 * @tc.desc : api test
289 */
290 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1600, TestSize.Level2)
291 {
292 OH_AVErrCode ret = AV_ERR_OK;
293 ret = OH_VideoEncoder_Flush(nullptr);
294 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
295 }
296
297 /**
298 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1700
299 * @tc.name : OH_VideoEncoder_Reset para error
300 * @tc.desc : api test
301 */
302 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1700, TestSize.Level2)
303 {
304 OH_AVErrCode ret = AV_ERR_OK;
305 ret = OH_VideoEncoder_Reset(nullptr);
306 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
307 }
308
309 /**
310 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1800
311 * @tc.name : OH_VideoEncoder_Reset para error
312 * @tc.desc : api test
313 */
314 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1800, TestSize.Level2)
315 {
316 format = OH_VideoEncoder_GetOutputDescription(nullptr);
317 ASSERT_EQ(format, nullptr);
318 }
319
320 /**
321 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_1900
322 * @tc.name : OH_VideoEncoder_SetParameter para error
323 * @tc.desc : api test
324 */
325 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_1900, TestSize.Level2)
326 {
327 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
328 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_SetParameter(venc_, nullptr));
329 }
330
331 /**
332 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2000
333 * @tc.name : OH_VideoEncoder_SetParameter para error
334 * @tc.desc : api test
335 */
336 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2000, TestSize.Level2)
337 {
338 format = OH_AVFormat_Create();
339 ASSERT_NE(NULL, format);
340
341 string widthStr = "width";
342 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
343 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_SetParameter(NULL, format));
344 }
345
346 /**
347 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2100
348 * @tc.name : OH_VideoEncoder_GetSurface para error
349 * @tc.desc : api test
350 */
351 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2100, TestSize.Level2)
352 {
353 OH_AVErrCode ret = AV_ERR_OK;
354 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
355 ASSERT_NE(nullptr, venc_);
356 ret = OH_VideoEncoder_GetSurface(venc_, nullptr);
357 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
358 }
359
360 /**
361 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2200
362 * @tc.name : OH_VideoEncoder_FreeOutputData para error
363 * @tc.desc : api test
364 */
365 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2200, TestSize.Level2)
366 {
367 OH_AVErrCode ret = AV_ERR_OK;
368 ret = OH_VideoEncoder_FreeOutputData(nullptr, 0);
369 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
370 }
371
372 /**
373 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2300
374 * @tc.name : OH_VideoEncoder_FreeOutputData para error
375 * @tc.desc : api test
376 */
377 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2300, TestSize.Level2)
378 {
379 OH_AVErrCode ret = AV_ERR_OK;
380 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
381 ASSERT_NE(nullptr, venc_);
382 format = OH_AVFormat_Create();
383 ASSERT_NE(nullptr, format);
384 OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
385 OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, 1080);
386 OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
387
388 ret = OH_VideoEncoder_Configure(venc_, format);
389 ASSERT_EQ(ret, AV_ERR_OK);
390 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
391 usleep(1000000);
392 ret = OH_VideoEncoder_FreeOutputData(venc_, 9999999);
393 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
394 }
395
396 /**
397 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2400
398 * @tc.name : OH_VideoEncoder_NotifyEndOfStream para error
399 * @tc.desc : api test
400 */
401 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2400, TestSize.Level2)
402 {
403 OH_AVErrCode ret = AV_ERR_OK;
404 ret = OH_VideoEncoder_NotifyEndOfStream(nullptr);
405 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
406 }
407 /**
408 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2500
409 * @tc.name : OH_VideoEncoder_NotifyEndOfStream para error
410 * @tc.desc : api test
411 */
412 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2500, TestSize.Level2)
413 {
414 OH_AVErrCode ret = AV_ERR_OK;
415 ret = OH_VideoEncoder_NotifyEndOfStream(nullptr);
416 ASSERT_EQ(ret, AV_ERR_INVALID_VAL);
417 }
418
419 /**
420 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2600
421 * @tc.name : OH_VideoEncoder_PushInputData para error
422 * @tc.desc : api test
423 */
424 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2600, TestSize.Level2)
425 {
426 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
427 ASSERT_NE(nullptr, venc_);
428 OH_AVCodecBufferAttr attr;
429 attr.pts = -1;
430 attr.size = -1;
431 attr.offset = 0;
432 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
433
434 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_PushInputData(venc_, 0, attr));
435 }
436
437 /**
438 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2700
439 * @tc.name : OH_VideoEncoder_PushInputData para error
440 * @tc.desc : api test
441 */
442 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2700, TestSize.Level2)
443 {
444 OH_AVCodecBufferAttr attr;
445 attr.pts = 0;
446 attr.size = 0;
447 attr.offset = 0;
448 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
449 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_PushInputData(NULL, 0, attr));
450 }
451
452 /**
453 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2800
454 * @tc.name : OH_VideoEncoder_PushInputData para error
455 * @tc.desc : api test
456 */
457 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2800, TestSize.Level2)
458 {
459 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
460 ASSERT_NE(nullptr, venc_);
461 OH_AVCodecBufferAttr attr;
462 attr.pts = 0;
463 attr.size = 0;
464 attr.offset = 0;
465 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
466 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_PushInputData(NULL, 99999, attr));
467 }
468
469 /**
470 * @tc.number : VIDEO_ENCODE_ILLEGAL_PARA_2900
471 * @tc.name : OH_VideoEncoder_GetInputDescription para error
472 * * @tc.desc : api test
473 */
474 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_ILLEGAL_PARA_2900, TestSize.Level2)
475 {
476 ASSERT_EQ(nullptr, OH_VideoEncoder_GetInputDescription(nullptr));
477 }
478
479 /**
480 * @tc.number : VIDEO_ENCODE_CAPABILITY_0100
481 * @tc.name : OH_AVCodec_GetCapability para error
482 * @tc.desc : api test
483 */
484 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0100, TestSize.Level2)
485 {
486 const char *p = nullptr;
487 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability(p, true));
488 }
489
490 /**
491 * @tc.number : VIDEO_ENCODE_CAPABILITY_0200
492 * @tc.name : OH_AVCodec_GetCapability para error
493 * @tc.desc : api test
494 */
495 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0200, TestSize.Level2)
496 {
497 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability("", true));
498 }
499
500 /**
501 * @tc.number : VIDEO_ENCODE_CAPABILITY_0300
502 * @tc.name : OH_AVCodec_GetCapability para error
503 * @tc.desc : api test
504 */
505 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0300, TestSize.Level2)
506 {
507 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability("notexist", true));
508 }
509
510 /**
511 * @tc.number : VIDEO_ENCODE_CAPABILITY_0400
512 * @tc.name : OH_AVCodec_GetCapability
513 * @tc.desc : api test
514 */
515 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0400, TestSize.Level2)
516 {
517 ASSERT_NE(nullptr, OH_AVCodec_GetCapability(codecMime, true));
518 }
519
520 /**
521 * @tc.number : VIDEO_ENCODE_CAPABILITY_0500
522 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
523 * @tc.desc : api test
524 */
525 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0500, TestSize.Level2)
526 {
527 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory("", true, HARDWARE));
528 }
529 /**
530 * @tc.number : VIDEO_ENCODE_CAPABILITY_9900
531 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
532 * @tc.desc : api test
533 */
534 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_9900, TestSize.Level2)
535 {
536 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory(nullptr, true, HARDWARE));
537 }
538
539 /**
540 * @tc.number : VIDEO_ENCODE_CAPABILITY_0600
541 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
542 * @tc.desc : api test
543 */
544 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0600, TestSize.Level2)
545 {
546 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory("notexist", true, HARDWARE));
547 }
548
549 /**
550 * @tc.number : VIDEO_ENCODE_CAPABILITY_0700
551 * @tc.name : OH_AVCodec_GetCapabilityByCategory param correct
552 * @tc.desc : api test
553 */
554 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0700, TestSize.Level2)
555 {
556 ASSERT_NE(nullptr, OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE));
557 }
558
559 /**
560 * @tc.number : VIDEO_ENCODE_CAPABILITY_0800
561 * @tc.name : OH_AVCapability_IsHardware param error
562 * @tc.desc : api test
563 */
564 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0800, TestSize.Level2)
565 {
566 ASSERT_EQ(false, OH_AVCapability_IsHardware(nullptr));
567 }
568
569 /**
570 * @tc.number : VIDEO_ENCODE_CAPABILITY_0900
571 * @tc.name : OH_AVCapability_IsHardware param correct
572 * @tc.desc : api test
573 */
574 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_0900, TestSize.Level2)
575 {
576 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
577 ASSERT_NE(nullptr, capability);
578 ASSERT_EQ(true, OH_AVCapability_IsHardware(capability));
579 }
580
581 /**
582 * @tc.number : VIDEO_ENCODE_CAPABILITY_1000
583 * @tc.name : OH_AVCapability_GetName param error
584 * @tc.desc : api test
585 */
586 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1000, TestSize.Level2)
587 {
588 const char *name = OH_AVCapability_GetName(nullptr);
589 ASSERT_NE(name, nullptr);
590 ASSERT_EQ(strlen(name), 0);
591 }
592
593 /**
594 * @tc.number : VIDEO_ENCODE_CAPABILITY_1100
595 * @tc.name : OH_AVCapability_GetName param correct
596 * @tc.desc : api test
597 */
598 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1100, TestSize.Level2)
599 {
600 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
601 ASSERT_NE(nullptr, capability);
602 const char *name = OH_AVCapability_GetName(capability);
603 ASSERT_NE(name, nullptr);
604 ASSERT_EQ(strlen(name) > 0, true);
605 }
606
607 /**
608 * @tc.number : VIDEO_ENCODE_CAPABILITY_1200
609 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param error
610 * @tc.desc : api test
611 */
612 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1200, TestSize.Level2)
613 {
614 int32_t maxSupportedInstance = OH_AVCapability_GetMaxSupportedInstances(nullptr);
615 ASSERT_EQ(maxSupportedInstance, 0);
616 }
617
618 /**
619 * @tc.number : VIDEO_ENCODE_CAPABILITY_1300
620 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param correct
621 * @tc.desc : api test
622 */
623 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1300, TestSize.Level2)
624 {
625 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
626 ASSERT_NE(nullptr, capability);
627
628 string codec_name = OH_AVCapability_GetName(capability);
629 if (codec_name == "OMX.hisi.video.encoder.avc") {
630 ASSERT_EQ(16, OH_AVCapability_GetMaxSupportedInstances(capability));
631 } else {
632 ASSERT_EQ(4, OH_AVCapability_GetMaxSupportedInstances(capability));
633 }
634 }
635
636 /**
637 * @tc.number : VIDEO_ENCODE_CAPABILITY_1400
638 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
639 * @tc.desc : api test
640 */
641 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1400, TestSize.Level2)
642 {
643 OH_AVErrCode ret = AV_ERR_OK;
644 OH_AVRange range;
645 ret = OH_AVCapability_GetEncoderBitrateRange(nullptr, &range);
646 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
647 }
648
649 /**
650 * @tc.number : VIDEO_ENCODE_CAPABILITY_1500
651 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
652 * @tc.desc : api test
653 */
654
655 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1500, TestSize.Level2)
656 {
657 OH_AVErrCode ret = AV_ERR_OK;
658
659 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
660 ASSERT_NE(nullptr, capability);
661
662 ret = OH_AVCapability_GetEncoderBitrateRange(capability, nullptr);
663 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
664 }
665
666 /**
667 * @tc.number : VIDEO_ENCODE_CAPABILITY_1700
668 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param correct
669 * @tc.desc : api test
670 */
671 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1700, TestSize.Level2)
672 {
673 OH_AVErrCode ret = AV_ERR_OK;
674 OH_AVRange range;
675 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
676 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
677 ASSERT_NE(nullptr, capability);
678 ret = OH_AVCapability_GetEncoderBitrateRange(capability, &range);
679 ASSERT_EQ(AV_ERR_OK, ret);
680 cout << "max val " << range.maxVal << " min val " << range.minVal << endl;
681 ASSERT_EQ(true, (range.minVal > 0));
682 ASSERT_EQ(true, (range.maxVal > 0));
683 }
684
685 /**
686 * @tc.number : VIDEO_ENCODE_CAPABILITY_1800
687 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param error
688 * @tc.desc : api test
689 */
690 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1800, TestSize.Level2)
691 {
692 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(nullptr, BITRATE_MODE_CBR);
693 ASSERT_EQ(false, isSupported);
694 }
695
696 /**
697 * @tc.number : VIDEO_ENCODE_CAPABILITY_1900
698 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
699 * @tc.desc : api test
700 */
701 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_1900, TestSize.Level2)
702 {
703 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
704 ASSERT_NE(nullptr, capability);
705 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_CBR);
706 ASSERT_EQ(isSupported, true);
707 }
708
709 /**
710 * @tc.number : VIDEO_ENCODE_CAPABILITY_2000
711 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
712 * @tc.desc : api test
713 */
714 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2000, TestSize.Level2)
715 {
716 OH_AVErrCode ret = AV_ERR_OK;
717 OH_AVRange range;
718 ret = OH_AVCapability_GetEncoderQualityRange(nullptr, &range);
719 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
720 }
721
722 /**
723 * @tc.number : VIDEO_ENCODE_CAPABILITY_2100
724 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
725 * @tc.desc : api test
726 */
727 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2100, TestSize.Level2)
728 {
729 OH_AVErrCode ret = AV_ERR_OK;
730 ret = OH_AVCapability_GetEncoderQualityRange(nullptr, nullptr);
731 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
732 }
733
734 /**
735 * @tc.number : VIDEO_ENCODE_CAPABILITY_2200
736 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
737 * @tc.desc : api test
738 */
739 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2200, TestSize.Level2)
740 {
741 OH_AVErrCode ret = AV_ERR_OK;
742 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
743 ASSERT_NE(nullptr, capability);
744 ret = OH_AVCapability_GetEncoderQualityRange(capability, nullptr);
745 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
746 }
747
748 /**
749 * @tc.number : VIDEO_ENCODE_CAPABILITY_2300
750 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
751 * @tc.desc : api test
752 */
753 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2300, TestSize.Level2)
754 {
755 OH_AVErrCode ret = AV_ERR_OK;
756 OH_AVRange range;
757 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
758 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
759 ASSERT_NE(nullptr, capability);
760 ret = OH_AVCapability_GetEncoderQualityRange(capability, &range);
761 ASSERT_EQ(AV_ERR_OK, ret);
762 }
763
764 /**
765 * @tc.number : VIDEO_ENCODE_CAPABILITY_2400
766 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
767 * @tc.desc : api test
768 */
769 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2400, TestSize.Level2)
770 {
771 OH_AVErrCode ret = AV_ERR_OK;
772 ret = OH_AVCapability_GetEncoderComplexityRange(nullptr, nullptr);
773 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
774 }
775
776 /**
777 * @tc.number : VIDEO_ENCODE_CAPABILITY_2500
778 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
779 * @tc.desc : api test
780 */
781 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2500, TestSize.Level2)
782 {
783 OH_AVErrCode ret = AV_ERR_OK;
784 OH_AVRange range;
785 ret = OH_AVCapability_GetEncoderComplexityRange(nullptr, &range);
786 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
787 }
788
789 /**
790 * @tc.number : VIDEO_ENCODE_CAPABILITY_2700
791 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
792 * @tc.desc : api test
793 */
794 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2700, TestSize.Level2)
795 {
796 OH_AVErrCode ret = AV_ERR_OK;
797 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
798 ASSERT_NE(nullptr, capability);
799 ret = OH_AVCapability_GetEncoderComplexityRange(capability, nullptr);
800 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
801 }
802
803 /**
804 * @tc.number : VIDEO_ENCODE_CAPABILITY_2800
805 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param correct
806 * @tc.desc : api test
807 */
808 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_2800, TestSize.Level2)
809 {
810 OH_AVErrCode ret = AV_ERR_OK;
811 OH_AVRange range;
812 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
813 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
814 ASSERT_NE(nullptr, capability);
815 ret = OH_AVCapability_GetEncoderComplexityRange(capability, &range);
816 ASSERT_EQ(AV_ERR_OK, ret);
817 }
818
819 /**
820 * @tc.number : VIDEO_ENCODE_CAPABILITY_3100
821 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
822 * @tc.desc : api test
823 */
824 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3100, TestSize.Level2)
825 {
826 OH_AVErrCode ret = AV_ERR_OK;
827 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
828 ASSERT_NE(nullptr, capability);
829 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
830 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
831 }
832
833 /**
834 * @tc.number : VIDEO_ENCODE_CAPABILITY_3200
835 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
836 * @tc.desc : api test
837 */
838 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3200, TestSize.Level2)
839 {
840 OH_AVErrCode ret = AV_ERR_OK;
841 int32_t alignment = 0;
842 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
843 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
844 }
845
846 /**
847 * @tc.number : VIDEO_ENCODE_CAPABILITY_3300
848 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
849 * @tc.desc : api test
850 */
851 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3300, TestSize.Level2)
852 {
853 OH_AVErrCode ret = AV_ERR_OK;
854 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
855 ASSERT_NE(nullptr, capability);
856 int32_t alignment = 0;
857 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
858 ASSERT_EQ(AV_ERR_OK, ret);
859 ASSERT_EQ(alignment >= 0, true);
860 }
861
862 /**
863 * @tc.number : VIDEO_ENCODE_CAPABILITY_3400
864 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
865 * @tc.desc : api test
866 */
867 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3400, TestSize.Level2)
868 {
869 OH_AVErrCode ret = AV_ERR_OK;
870 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
871 ASSERT_NE(nullptr, capability);
872 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
873 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
874 }
875
876 /**
877 * @tc.number : VIDEO_ENCODE_CAPABILITY_3500
878 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
879 * @tc.desc : api test
880 */
881 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3500, TestSize.Level2)
882 {
883 OH_AVErrCode ret = AV_ERR_OK;
884 int32_t alignment = 0;
885 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
886 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
887 }
888
889 /**
890 * @tc.number : VIDEO_ENCODE_CAPABILITY_3600
891 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
892 * @tc.desc : api test
893 */
894 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3600, TestSize.Level2)
895 {
896 OH_AVErrCode ret = AV_ERR_OK;
897 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
898 ASSERT_NE(nullptr, capability);
899 int32_t alignment = 0;
900 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
901 ASSERT_EQ(AV_ERR_OK, ret);
902 ASSERT_EQ(alignment >= 0, true);
903 }
904
905 /**
906 * @tc.number : VIDEO_ENCODE_CAPABILITY_3700
907 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
908 * @tc.desc : api test
909 */
910 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3700, TestSize.Level2)
911 {
912 OH_AVErrCode ret = AV_ERR_OK;
913 OH_AVRange range;
914 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
915 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
916 ASSERT_NE(nullptr, capability);
917 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, 1920, &range);
918 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
919 }
920
921 /**
922 * @tc.number : VIDEO_ENCODE_CAPABILITY_3800
923 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
924 * @tc.desc : api test
925 */
926 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3800, TestSize.Level2)
927 {
928 OH_AVErrCode ret = AV_ERR_OK;
929 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
930 ASSERT_NE(nullptr, capability);
931 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 1920, nullptr);
932 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
933 }
934
935 /**
936 * @tc.number : VIDEO_ENCODE_CAPABILITY_3900
937 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
938 * @tc.desc : api test
939 */
940 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_3900, TestSize.Level2)
941 {
942 OH_AVErrCode ret = AV_ERR_OK;
943 OH_AVRange range;
944 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
945 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
946 ASSERT_NE(nullptr, capability);
947 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
948 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
949 }
950
951 /**
952 * @tc.number : VIDEO_ENCODE_CAPABILITY_4000
953 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param correct
954 * @tc.desc : api test
955 */
956 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4000, TestSize.Level2)
957 {
958 OH_AVErrCode ret = AV_ERR_OK;
959 OH_AVRange range;
960 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
961 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
962 ASSERT_NE(nullptr, capability);
963 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 1080, &range);
964 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
965 ASSERT_EQ(AV_ERR_OK, ret);
966 ASSERT_EQ(true, (range.minVal >= 0));
967 ASSERT_EQ(true, (range.maxVal > 0));
968 }
969
970 /**
971 * @tc.number : VIDEO_ENCODE_CAPABILITY_4100
972 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
973 * @tc.desc : api test
974 */
975 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4100, TestSize.Level2)
976 {
977 OH_AVErrCode ret = AV_ERR_OK;
978 OH_AVRange range;
979 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
980 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
981 ASSERT_NE(nullptr, capability);
982 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, 1080, &range);
983 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
984 }
985
986 /**
987 * @tc.number : VIDEO_ENCODE_CAPABILITY_4200
988 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
989 * @tc.desc : api test
990 */
991 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4200, TestSize.Level2)
992 {
993 OH_AVErrCode ret = AV_ERR_OK;
994 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
995 ASSERT_NE(nullptr, capability);
996 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 1080, nullptr);
997 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
998 }
999
1000 /**
1001 * @tc.number : VIDEO_ENCODE_CAPABILITY_4300
1002 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1003 * @tc.desc : api test
1004 */
1005 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4300, TestSize.Level2)
1006 {
1007 OH_AVErrCode ret = AV_ERR_OK;
1008 OH_AVRange range;
1009 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1010 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1011 ASSERT_NE(nullptr, capability);
1012 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1013 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1014 }
1015
1016 /**
1017 * @tc.number : VIDEO_ENCODE_CAPABILITY_4400
1018 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
1019 * @tc.desc : api test
1020 */
1021 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4400, TestSize.Level2)
1022 {
1023 OH_AVErrCode ret = AV_ERR_OK;
1024 OH_AVRange range;
1025 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1026 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1027 ASSERT_NE(nullptr, capability);
1028 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 1920, &range);
1029 ASSERT_EQ(AV_ERR_OK, ret);
1030 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1031 ASSERT_EQ(true, (range.minVal >= 0));
1032 ASSERT_EQ(true, (range.maxVal > 0));
1033 }
1034
1035 /**
1036 * @tc.number : VIDEO_ENCODE_CAPABILITY_4500
1037 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1038 * @tc.desc : api test
1039 */
1040 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4500, TestSize.Level2)
1041 {
1042 OH_AVErrCode ret = AV_ERR_OK;
1043 OH_AVRange range;
1044 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1045 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1046 }
1047
1048 /**
1049 * @tc.number : VIDEO_ENCODE_CAPABILITY_4600
1050 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1051 * @tc.desc : api test
1052 */
1053 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4600, TestSize.Level2)
1054 {
1055 OH_AVErrCode ret = AV_ERR_OK;
1056 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1057 ASSERT_NE(nullptr, capability);
1058 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1059 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1060 }
1061
1062 /**
1063 * @tc.number : VIDEO_ENCODE_CAPABILITY_4700
1064 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
1065 * @tc.desc : api test
1066 */
1067 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4700, TestSize.Level2)
1068 {
1069 OH_AVErrCode ret = AV_ERR_OK;
1070 OH_AVRange range;
1071 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1072 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1073 ASSERT_NE(nullptr, capability);
1074 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
1075 ASSERT_EQ(AV_ERR_OK, ret);
1076 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1077 ASSERT_EQ(true, (range.minVal >= 0));
1078 ASSERT_EQ(true, (range.maxVal > 0));
1079 }
1080
1081 /**
1082 * @tc.number : VIDEO_ENCODE_CAPABILITY_4800
1083 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1084 * @tc.desc : api test
1085 */
1086 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4800, TestSize.Level2)
1087 {
1088 OH_AVErrCode ret = AV_ERR_OK;
1089 OH_AVRange range;
1090 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1091 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1092 }
1093
1094 /**
1095 * @tc.number : VIDEO_ENCODE_CAPABILITY_4900
1096 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1097 * @tc.desc : api test
1098 */
1099 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_4900, TestSize.Level2)
1100 {
1101 OH_AVErrCode ret = AV_ERR_OK;
1102 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1103 ASSERT_NE(nullptr, capability);
1104 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1105 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1106 }
1107
1108 /**
1109 * @tc.number : VIDEO_ENCODE_CAPABILITY_5000
1110 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
1111 * @tc.desc : api test
1112 */
1113 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5000, TestSize.Level2)
1114 {
1115 OH_AVErrCode ret = AV_ERR_OK;
1116 OH_AVRange range;
1117 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1118 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1119 ASSERT_NE(nullptr, capability);
1120 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
1121 ASSERT_EQ(AV_ERR_OK, ret);
1122 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1123 ASSERT_EQ(true, (range.minVal >= 0));
1124 ASSERT_EQ(true, (range.maxVal > 0));
1125 }
1126
1127 /**
1128 * @tc.number : VIDEO_ENCODE_CAPABILITY_5100
1129 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1130 * @tc.desc : api test
1131 */
1132 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5100, TestSize.Level2)
1133 {
1134 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1135 ASSERT_NE(nullptr, capability);
1136 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, 1080));
1137 }
1138
1139 /**
1140 * @tc.number : VIDEO_ENCODE_CAPABILITY_5200
1141 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1142 * @tc.desc : api test
1143 */
1144 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5200, TestSize.Level2)
1145 {
1146 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1147 ASSERT_NE(nullptr, capability);
1148 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 1920, 0));
1149 }
1150 /**
1151 * @tc.number : VIDEO_ENCODE_CAPABILITY_5300
1152 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1153 * @tc.desc : api test
1154 */
1155 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5300, TestSize.Level2)
1156 {
1157 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, 1920, 1080));
1158 }
1159
1160 /**
1161 * @tc.number : VIDEO_ENCODE_CAPABILITY_5400
1162 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1163 * @tc.desc : api test
1164 */
1165 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5400, TestSize.Level2)
1166 {
1167 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1168 ASSERT_NE(nullptr, capability);
1169 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, 1920, 1080));
1170 }
1171
1172 /**
1173 * @tc.number : VIDEO_ENCODE_CAPABILITY_5500
1174 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1175 * @tc.desc : api test
1176 */
1177 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5500, TestSize.Level2)
1178 {
1179 OH_AVErrCode ret = AV_ERR_OK;
1180 OH_AVRange range;
1181 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1182 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1183 }
1184
1185 /**
1186 * @tc.number : VIDEO_ENCODE_CAPABILITY_5600
1187 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1188 * @tc.desc : api test
1189 */
1190 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5600, TestSize.Level2)
1191 {
1192 OH_AVErrCode ret = AV_ERR_OK;
1193 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1194 ASSERT_NE(nullptr, capability);
1195 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1196 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1197 }
1198
1199 /**
1200 * @tc.number : VIDEO_ENCODE_CAPABILITY_5700
1201 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1202 * @tc.desc : api test
1203 */
1204 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5700, TestSize.Level2)
1205 {
1206 OH_AVErrCode ret = AV_ERR_OK;
1207 OH_AVRange range;
1208 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1209 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1210 ASSERT_NE(nullptr, capability);
1211 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1212 ASSERT_EQ(AV_ERR_OK, ret);
1213 ASSERT_EQ(true, (range.minVal >= 0));
1214 ASSERT_EQ(true, (range.maxVal > 0));
1215 }
1216
1217 /**
1218 * @tc.number : VIDEO_ENCODE_CAPABILITY_5800
1219 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1220 * @tc.desc : api test
1221 */
1222 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5800, TestSize.Level2)
1223 {
1224 OH_AVErrCode ret = AV_ERR_OK;
1225 OH_AVRange range;
1226 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, 1920, 1080, &range);
1227 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1228 }
1229
1230 /**
1231 * @tc.number : VIDEO_ENCODE_CAPABILITY_5900
1232 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1233 * @tc.desc : api test
1234 */
1235 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_5900, TestSize.Level2)
1236 {
1237 OH_AVErrCode ret = AV_ERR_OK;
1238 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1239 ASSERT_NE(nullptr, capability);
1240 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1920, 1080, nullptr);
1241 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1242 }
1243
1244 /**
1245 * @tc.number : VIDEO_ENCODE_CAPABILITY_6000
1246 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1247 * @tc.desc : api test
1248 */
1249 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6000, TestSize.Level2)
1250 {
1251 OH_AVErrCode ret = AV_ERR_OK;
1252 OH_AVRange range;
1253 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1254 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1255 ASSERT_NE(nullptr, capability);
1256 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, 1080, &range);
1257 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1258 }
1259
1260 /**
1261 * @tc.number : VIDEO_ENCODE_CAPABILITY_6100
1262 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1263 * @tc.desc : api test
1264 */
1265 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6100, TestSize.Level2)
1266 {
1267 OH_AVErrCode ret = AV_ERR_OK;
1268 OH_AVRange range;
1269 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1270 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1271 ASSERT_NE(nullptr, capability);
1272 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1920, 0, &range);
1273 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1274 }
1275
1276 /**
1277 * @tc.number : VIDEO_ENCODE_CAPABILITY_6200
1278 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1279 * @tc.desc : api test
1280 */
1281 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6200, TestSize.Level2)
1282 {
1283 OH_AVErrCode ret = AV_ERR_OK;
1284 OH_AVRange range;
1285 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1286 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1287 ASSERT_NE(nullptr, capability);
1288 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 1920, 1080, &range);
1289 ASSERT_EQ(AV_ERR_OK, ret);
1290 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1291 ASSERT_EQ(true, (range.minVal >= 0));
1292 ASSERT_EQ(true, (range.maxVal > 0));
1293 }
1294
1295 /**
1296 * @tc.number : VIDEO_ENCODE_CAPABILITY_6300
1297 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1298 * @tc.desc : api test
1299 */
1300 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6300, TestSize.Level2)
1301 {
1302 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1303 ASSERT_NE(nullptr, capability);
1304 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, 1080, 30));
1305 }
1306
1307 /**
1308 * @tc.number : VIDEO_ENCODE_CAPABILITY_6400
1309 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1310 * @tc.desc : api test
1311 */
1312 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6400, TestSize.Level2)
1313 {
1314 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1315 ASSERT_NE(nullptr, capability);
1316 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 1920, 0, 30));
1317 }
1318
1319 /**
1320 * @tc.number : VIDEO_ENCODE_CAPABILITY_6500
1321 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1322 * @tc.desc : api test
1323 */
1324 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6500, TestSize.Level2)
1325 {
1326 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1327 ASSERT_NE(nullptr, capability);
1328 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 1920, 1080, 0));
1329 }
1330
1331 /**
1332 * @tc.number : VIDEO_ENCODE_CAPABILITY_6600
1333 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1334 * @tc.desc : api test
1335 */
1336 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6600, TestSize.Level2)
1337 {
1338 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, 1920, 1080, 30));
1339 }
1340
1341 /**
1342 * @tc.number : VIDEO_ENCODE_CAPABILITY_6700
1343 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1344 * @tc.desc : api test
1345 */
1346 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6700, TestSize.Level2)
1347 {
1348 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1349 ASSERT_NE(nullptr, capability);
1350 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 1920, 1080, 30));
1351 }
1352
1353 /**
1354 * @tc.number : VIDEO_ENCODE_CAPABILITY_6800
1355 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1356 * @tc.desc : api test
1357 */
1358 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6800, TestSize.Level2)
1359 {
1360 OH_AVErrCode ret = AV_ERR_OK;
1361 const int32_t *pixelFormat = nullptr;
1362 uint32_t pixelFormatNum = 0;
1363 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1364 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1365 }
1366
1367 /**
1368 * @tc.number : VIDEO_ENCODE_CAPABILITY_6900
1369 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1370 * @tc.desc : api test
1371 */
1372 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_6900, TestSize.Level2)
1373 {
1374 OH_AVErrCode ret = AV_ERR_OK;
1375 uint32_t pixelFormatNum = 0;
1376 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1377 ASSERT_NE(nullptr, capability);
1378 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1379 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1380 }
1381
1382 /**
1383 * @tc.number : VIDEO_ENCODE_CAPABILITY_7000
1384 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1385 * @tc.desc : api test
1386 */
1387 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7000, TestSize.Level2)
1388 {
1389 OH_AVErrCode ret = AV_ERR_OK;
1390 const int32_t *pixelFormat = nullptr;
1391 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1392 ASSERT_NE(nullptr, capability);
1393 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1394 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1395 }
1396
1397 /**
1398 * @tc.number : VIDEO_ENCODE_CAPABILITY_7100
1399 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1400 * @tc.desc : api test
1401 */
1402 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7100, TestSize.Level2)
1403 {
1404 OH_AVErrCode ret = AV_ERR_OK;
1405 const int32_t *pixelFormat = nullptr;
1406 uint32_t pixelFormatNum = 0;
1407 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1408 ASSERT_NE(nullptr, capability);
1409 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1410 ASSERT_EQ(AV_ERR_OK, ret);
1411 }
1412
1413 /**
1414 * @tc.number : VIDEO_ENCODE_CAPABILITY_7200
1415 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1416 * @tc.desc : api test
1417 */
1418 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7200, TestSize.Level2)
1419 {
1420 OH_AVErrCode ret = AV_ERR_OK;
1421 const int32_t *profiles = nullptr;
1422 uint32_t profileNum = 0;
1423 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
1424 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1425 }
1426
1427 /**
1428 * @tc.number : VIDEO_ENCODE_CAPABILITY_7300
1429 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1430 * @tc.desc : api test
1431 */
1432 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7300, TestSize.Level2)
1433 {
1434 OH_AVErrCode ret = AV_ERR_OK;
1435 uint32_t profileNum = 0;
1436 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1437 ASSERT_NE(nullptr, capability);
1438 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
1439 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1440 }
1441
1442 /**
1443 * @tc.number : VIDEO_ENCODE_CAPABILITY_7400
1444 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1445 * @tc.desc : api test
1446 */
1447 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7400, TestSize.Level2)
1448 {
1449 OH_AVErrCode ret = AV_ERR_OK;
1450 const int32_t *profiles = nullptr;
1451 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1452 ASSERT_NE(nullptr, capability);
1453 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
1454 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1455 }
1456
1457 /**
1458 * @tc.number : VIDEO_ENCODE_CAPABILITY_7500
1459 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1460 * @tc.desc : api test
1461 */
1462 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7500, TestSize.Level2)
1463 {
1464 OH_AVErrCode ret = AV_ERR_OK;
1465 const int32_t *profiles = nullptr;
1466 uint32_t profileNum = 0;
1467 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1468 ASSERT_NE(nullptr, capability);
1469 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1470 ASSERT_EQ(AV_ERR_OK, ret);
1471 }
1472
1473 /**
1474 * @tc.number : VIDEO_ENCODE_CAPABILITY_7600
1475 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1476 * @tc.desc : api test
1477 */
1478 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7600, TestSize.Level2)
1479 {
1480 OH_AVErrCode ret = AV_ERR_OK;
1481 const int32_t *levels = nullptr;
1482 uint32_t levelNum = 0;
1483 ret = OH_AVCapability_GetSupportedLevelsForProfile(nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
1484 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1485 }
1486
1487 /**
1488 * @tc.number : VIDEO_ENCODE_CAPABILITY_7700
1489 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1490 * @tc.desc : api test
1491 */
1492 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7700, TestSize.Level2)
1493 {
1494 OH_AVErrCode ret = AV_ERR_OK;
1495 const int32_t *levels = nullptr;
1496 uint32_t levelNum = 0;
1497 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1498 ASSERT_NE(nullptr, capability);
1499 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
1500 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1501 }
1502
1503 /**
1504 * @tc.number : VIDEO_ENCODE_CAPABILITY_7800
1505 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1506 * @tc.desc : api test
1507 */
1508 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7800, TestSize.Level2)
1509 {
1510 OH_AVErrCode ret = AV_ERR_OK;
1511 uint32_t levelNum = 0;
1512 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1513 ASSERT_NE(nullptr, capability);
1514 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
1515 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1516 }
1517
1518 /**
1519 * @tc.number : VIDEO_ENCODE_CAPABILITY_7900
1520 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1521 * @tc.desc : api test
1522 */
1523 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_7900, TestSize.Level2)
1524 {
1525 OH_AVErrCode ret = AV_ERR_OK;
1526 const int32_t *levels = nullptr;
1527 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1528 ASSERT_NE(nullptr, capability);
1529 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, nullptr);
1530 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1531 }
1532
1533 /**
1534 * @tc.number : VIDEO_ENCODE_CAPABILITY_8000
1535 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
1536 * @tc.desc : api test
1537 */
1538 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_8000, TestSize.Level2)
1539 {
1540 OH_AVErrCode ret = AV_ERR_OK;
1541 const int32_t *levels = nullptr;
1542 uint32_t levelNum = 0;
1543 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1544 ASSERT_NE(nullptr, capability);
1545 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, &levelNum);
1546 ASSERT_EQ(AV_ERR_OK, ret);
1547 }
1548
1549 /**
1550 * @tc.number : VIDEO_ENCODE_CAPABILITY_8100
1551 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1552 * @tc.desc : api test
1553 */
1554 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_8100, TestSize.Level2)
1555 {
1556 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(nullptr, AVC_PROFILE_BASELINE, 1));
1557 }
1558
1559 /**
1560 * @tc.number : VIDEO_ENCODE_CAPABILITY_8200
1561 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
1562 * @tc.desc : api test
1563 */
1564 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_8200, TestSize.Level2)
1565 {
1566 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1567 ASSERT_NE(nullptr, capability);
1568 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
1569 }
1570
1571 /**
1572 * @tc.number : VIDEO_ENCODE_CAPABILITY_8300
1573 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
1574 * @tc.desc : api test
1575 */
1576 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_CAPABILITY_8300, TestSize.Level2)
1577 {
1578 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(codecMime, true, HARDWARE);
1579 ASSERT_NE(nullptr, capability);
1580 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
1581 }
1582
1583 /**
1584 * @tc.number : VIDEO_ENCODE_API_0100
1585 * @tc.name : create create
1586 * @tc.desc : function test
1587 */
1588 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0100, TestSize.Level2)
1589 {
1590 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
1591 ASSERT_NE(venc_, NULL);
1592 OH_AVCodec *venc_2 = OH_VideoEncoder_CreateByMime(codecMime);
1593 ASSERT_NE(venc_2, NULL);
1594 OH_VideoEncoder_Destroy(venc_2);
1595 venc_2 = nullptr;
1596 }
1597
1598 /**
1599 * @tc.number : VIDEO_ENCODE_API_3100
1600 * @tc.name : create create
1601 * @tc.desc : function test
1602 */
1603 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_3100, TestSize.Level2)
1604 {
1605 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1606 ASSERT_NE(venc_, NULL);
1607 OH_AVCodec *venc_2 = OH_VideoEncoder_CreateByName(g_codecName);
1608 ASSERT_NE(venc_2, NULL);
1609 OH_VideoEncoder_Destroy(venc_2);
1610 venc_2 = nullptr;
1611 }
1612
1613 /**
1614 * @tc.number : VIDEO_ENCODE_API_0200
1615 * @tc.name : create configure configure
1616 * @tc.desc : function test
1617 */
1618 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0200, TestSize.Level2)
1619 {
1620 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1621 ASSERT_NE(NULL, venc_);
1622
1623 format = OH_AVFormat_Create();
1624 ASSERT_NE(NULL, format);
1625
1626 string widthStr = "width";
1627 string heightStr = "height";
1628 string frameRateStr = "frame_rate";
1629 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1630 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1631 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1632
1633 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1634 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Configure(venc_, format));
1635 }
1636
1637 /**
1638 * @tc.number : VIDEO_ENCODE_API_0300
1639 * @tc.name : create configure start start
1640 * @tc.desc : function test
1641 */
1642 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0300, TestSize.Level2)
1643 {
1644 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1645 ASSERT_NE(NULL, venc_);
1646
1647 format = OH_AVFormat_Create();
1648 ASSERT_NE(NULL, format);
1649
1650 string widthStr = "width";
1651 string heightStr = "height";
1652 string frameRateStr = "frame_rate";
1653 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1654 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1655 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1656 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1657 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
1658 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Start(venc_));
1659 }
1660
1661 /**
1662 * @tc.number : VIDEO_ENCODE_API_0400
1663 * @tc.name : create configure start stop stop
1664 * @tc.desc : function test
1665 */
1666 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0400, TestSize.Level2)
1667 {
1668 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1669 ASSERT_NE(NULL, venc_);
1670
1671 format = OH_AVFormat_Create();
1672 ASSERT_NE(NULL, format);
1673
1674 string widthStr = "width";
1675 string heightStr = "height";
1676 string frameRateStr = "frame_rate";
1677 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1678 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1679 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1680
1681 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1682 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
1683 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Stop(venc_));
1684 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Stop(venc_));
1685 }
1686
1687 /**
1688 * @tc.number : VIDEO_ENCODE_API_0500
1689 * @tc.name : create configure start stop reset reset
1690 * @tc.desc : function test
1691 */
1692 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0500, TestSize.Level2)
1693 {
1694 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1695 ASSERT_NE(NULL, venc_);
1696
1697 format = OH_AVFormat_Create();
1698 ASSERT_NE(NULL, format);
1699
1700 string widthStr = "width";
1701 string heightStr = "height";
1702 string frameRateStr = "frame_rate";
1703 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1704 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1705 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1706
1707 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1708 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
1709 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Stop(venc_));
1710 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Reset(venc_));
1711 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Reset(venc_));
1712 }
1713
1714 /**
1715 * @tc.number : VIDEO_ENCODE_API_0600
1716 * @tc.name : create configure start EOS EOS
1717 * @tc.desc : function test
1718 */
1719 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0600, TestSize.Level2)
1720 {
1721 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1722 ASSERT_NE(NULL, venc_);
1723
1724 format = OH_AVFormat_Create();
1725 ASSERT_NE(NULL, format);
1726
1727 string widthStr = "width";
1728 string heightStr = "height";
1729 string frameRateStr = "frame_rate";
1730 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1731 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1732 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1733
1734 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1735 OH_AVCodecAsyncCallback cb_;
1736 cb_.onError = onError;
1737 cb_.onStreamChanged = onStreamChanged;
1738 cb_.onNeedInputData = onNeedInputData;
1739 cb_.onNeedOutputData = onNewOutputData;
1740 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, static_cast<void *>(signal_)));
1741
1742 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
1743 unique_lock<mutex> lock(signal_->inMutex_);
__anonc914af020302null1744 signal_->inCond_.wait(lock, [] { return signal_->inIdxQueue_.size() > 1; });
1745 uint32_t index = signal_->inIdxQueue_.front();
1746 OH_AVCodecBufferAttr attr;
1747 attr.pts = 0;
1748 attr.size = 0;
1749 attr.offset = 0;
1750 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
1751
1752 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_PushInputData(venc_, index, attr));
1753 signal_->inIdxQueue_.pop();
1754 index = signal_->inIdxQueue_.front();
1755 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_PushInputData(venc_, index, attr));
1756 signal_->inIdxQueue_.pop();
1757 }
1758
1759 /**
1760 * @tc.number : VIDEO_ENCODE_API_0700
1761 * @tc.name : create configure start flush flush
1762 * @tc.desc : function test
1763 */
1764 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0700, TestSize.Level2)
1765 {
1766 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1767 ASSERT_NE(NULL, venc_);
1768
1769 format = OH_AVFormat_Create();
1770 ASSERT_NE(NULL, format);
1771
1772 string widthStr = "width";
1773 string heightStr = "height";
1774 string frameRateStr = "frame_rate";
1775 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1776 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1777 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1778
1779 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1780 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
1781 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Flush(venc_));
1782 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_Flush(venc_));
1783 }
1784
1785 /**
1786 * @tc.number : VIDEO_ENCODE_API_0800
1787 * @tc.name : create configure start stop release release
1788 * @tc.desc : function test
1789 */
1790 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0800, TestSize.Level2)
1791 {
1792 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1793 ASSERT_NE(NULL, venc_);
1794
1795 format = OH_AVFormat_Create();
1796 ASSERT_NE(NULL, format);
1797
1798 string widthStr = "width";
1799 string heightStr = "height";
1800 string frameRateStr = "frame_rate";
1801 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1802 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1803 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1804
1805 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1806 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Start(venc_));
1807 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Stop(venc_));
1808 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Destroy(venc_));
1809 venc_ = nullptr;
1810 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Destroy(venc_));
1811 }
1812
1813 /**
1814 * @tc.number : VIDEO_ENCODE_API_0900
1815 * @tc.name : create create
1816 * @tc.desc : function test
1817 */
1818 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_0900, TestSize.Level2)
1819 {
1820 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
1821 ASSERT_NE(venc_, NULL);
1822 OH_AVCodec *venc_2 = OH_VideoEncoder_CreateByMime(codecMime);
1823 ASSERT_NE(venc_2, NULL);
1824 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Destroy(venc_2));
1825 venc_2 = nullptr;
1826 }
1827
1828 /**
1829 * @tc.number : VIDEO_ENCODE_API_1000
1830 * @tc.name : repeat OH_VideoEncoder_SetCallback
1831 * @tc.desc : function test
1832 */
1833 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1000, TestSize.Level2)
1834 {
1835 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1836 ASSERT_NE(venc_, NULL);
1837 OH_AVCodecAsyncCallback cb_;
1838 cb_.onError = onError;
1839 cb_.onStreamChanged = onStreamChanged;
1840 cb_.onNeedInputData = onNeedInputData;
1841 cb_.onNeedOutputData = onNewOutputData;
1842 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, NULL));
1843 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_SetCallback(venc_, cb_, NULL));
1844 }
1845
1846 /**
1847 * @tc.number : VIDEO_ENCODE_API_1100
1848 * @tc.name : repeat OH_VideoEncoder_GetOutputDescription
1849 * @tc.desc : function test
1850 */
1851 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1100, TestSize.Level2)
1852 {
1853 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1854 ASSERT_NE(venc_, NULL);
1855 format = OH_VideoEncoder_GetOutputDescription(venc_);
1856 ASSERT_NE(NULL, format);
1857 OH_AVFormat_Destroy(format);
1858 format = OH_VideoEncoder_GetOutputDescription(venc_);
1859 ASSERT_NE(NULL, format);
1860 }
1861
1862 /**
1863 * @tc.number : VIDEO_ENCODE_API_1200
1864 * @tc.name : repeat OH_VideoEncoder_SetParameter
1865 * @tc.desc : function test
1866 */
1867 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1200, TestSize.Level2)
1868 {
1869 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1870 ASSERT_NE(NULL, venc_);
1871
1872 format = OH_AVFormat_Create();
1873 ASSERT_NE(NULL, format);
1874
1875 string widthStr = "width";
1876 string heightStr = "height";
1877 string frameRateStr = "frame_rate";
1878 (void)OH_AVFormat_SetIntValue(format, widthStr.c_str(), DEFAULT_WIDTH);
1879 (void)OH_AVFormat_SetIntValue(format, heightStr.c_str(), DEFAULT_HEIGHT);
1880 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1881
1882 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_SetParameter(venc_, format));
1883 ASSERT_EQ(AV_ERR_INVALID_STATE, OH_VideoEncoder_SetParameter(venc_, format));
1884 }
1885 /**
1886 * @tc.number : VIDEO_ENCODE_API_1200
1887 * @tc.name : repeat OH_VideoEncoder_GetInputDescription
1888 * @tc.desc : function test
1889 */
1890 HWTEST_F(HwEncApiNdkTest, VIDEO_ENCODE_API_1300, TestSize.Level2)
1891 {
1892 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
1893 ASSERT_NE(NULL, venc_);
1894 format = OH_VideoEncoder_GetInputDescription(venc_);
1895 ASSERT_NE(NULL, format);
1896 OH_AVFormat_Destroy(format);
1897 format = OH_VideoEncoder_GetInputDescription(venc_);
1898 ASSERT_NE(NULL, format);
1899 }
1900 } // namespace