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