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 <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
25 namespace {
26 OH_AVCodec *venc_ = NULL;
27 OH_AVCapability *cap = nullptr;
28 OH_AVCapability *cap_hevc = nullptr;
29 constexpr uint32_t CODEC_NAME_SIZE = 128;
30 constexpr uint32_t DEFAULT_BITRATE = 1000000;
31 constexpr double DEFAULT_FRAME_RATE = 30.0;
32 constexpr uint32_t DEFAULT_QUALITY = 30;
33 constexpr uint32_t MAX_PROFILE_NUM = 3;
34 char g_codecName[CODEC_NAME_SIZE] = {};
35 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
36 OH_AVFormat *format;
37 const char *INP_DIR_720 = "/data/test/media/1280_720_nv.yuv";
38 constexpr uint32_t SECOND = 1000;
39 constexpr uint32_t DEFAULT_WIDTH = 1280;
40 constexpr uint32_t DEFAULT_HEIGHT = 720;
41 constexpr uint32_t MAX_QUALITY = 100;
42 constexpr uint32_t NO_SUPPORT_MODE = 100;
43 } // namespace
44 namespace OHOS {
45 namespace Media {
46 class HwEncFuncNdkTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp() override;
51 void TearDown() override;
52 void InputFunc();
53 void OutputFunc();
54 void Release();
55 int32_t Stop();
56 };
57 } // namespace Media
58 } // namespace OHOS
59
60 using namespace std;
61 using namespace OHOS;
62 using namespace OHOS::Media;
63 using namespace testing::ext;
64
SetUpTestCase()65 void HwEncFuncNdkTest::SetUpTestCase()
66 {
67 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
68 const char *tmpCodecName = OH_AVCapability_GetName(cap);
69 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
70 cout << "memcpy failed" << endl;
71 cout << "codecname: " << g_codecName << endl;
72 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
73 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
74 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
75 cout << "memcpy failed" << endl;
76 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
77 }
TearDownTestCase()78 void HwEncFuncNdkTest::TearDownTestCase() {}
SetUp()79 void HwEncFuncNdkTest::SetUp() {}
TearDown()80 void HwEncFuncNdkTest::TearDown()
81 {
82 if (venc_ != NULL) {
83 OH_VideoEncoder_Destroy(venc_);
84 venc_ = nullptr;
85 }
86 if (format != nullptr) {
87 OH_AVFormat_Destroy(format);
88 format = nullptr;
89 }
90 }
91 namespace {
92 /**
93 * @tc.number : VIDEO_ENCODE_FUNCTION_0100
94 * @tc.name : create by mime
95 * @tc.desc : function test
96 */
97 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0100, TestSize.Level1)
98 {
99 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
100 if (cap) {
101 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
102 ASSERT_NE(nullptr, venc_);
103 } else {
104 return;
105 }
106 }
107
108 /**
109 * @tc.number : VIDEO_ENCODE_FUNCTION_0200
110 * @tc.name : create by name
111 * @tc.desc : function test
112 */
113 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0200, TestSize.Level1)
114 {
115 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
116 if (cap) {
117 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
118 ASSERT_NE(nullptr, venc_);
119 } else {
120 return;
121 }
122 }
123
124 /**
125 * @tc.number : VIDEO_ENCODE_FUNCTION_0300
126 * @tc.name : create no exist encoder
127 * @tc.desc : function test
128 */
129 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0300, TestSize.Level1)
130 {
131 venc_ = OH_VideoEncoder_CreateByName("aabbccdd");
132 ASSERT_EQ(nullptr, venc_);
133 }
134
135 /**
136 * @tc.number : VIDEO_ENCODE_FUNCTION_0400
137 * @tc.name : test encode buffer
138 * @tc.desc : function test
139 */
140 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0400, TestSize.Level1)
141 {
142 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
143 if (cap) {
144 auto vEncSample = make_unique<VEncNdkSample>();
145 vEncSample->INP_DIR = INP_DIR_720;
146 vEncSample->DEFAULT_WIDTH = 1280;
147 vEncSample->DEFAULT_HEIGHT = 720;
148 vEncSample->DEFAULT_FRAME_RATE = 30;
149 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
150 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
151 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
152 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
153 vEncSample->WaitForEOS();
154 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
155 } else {
156 return;
157 }
158 }
159
160 /**
161 * @tc.number : VIDEO_ENCODE_FUNCTION_0500
162 * @tc.name : test encode surface
163 * @tc.desc : function test
164 */
165 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0500, TestSize.Level1)
166 {
167 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
168 if (cap) {
169 auto vEncSample = make_unique<VEncNdkSample>();
170 vEncSample->INP_DIR = INP_DIR_720;
171 vEncSample->DEFAULT_WIDTH = 1280;
172 vEncSample->DEFAULT_HEIGHT = 720;
173 vEncSample->DEFAULT_FRAME_RATE = 30;
174 vEncSample->SURF_INPUT = true;
175 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
176 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
177 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
178 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
179 vEncSample->WaitForEOS();
180 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
181 } else {
182 return;
183 }
184 }
185
186 /**
187 * @tc.number : VIDEO_ENCODE_FUNCTION_0600
188 * @tc.name : set force IDR when encoding
189 * @tc.desc : function test
190 */
191 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0600, TestSize.Level1)
192 {
193 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
194 if (cap) {
195 auto vEncSample = make_unique<VEncNdkSample>();
196 vEncSample->INP_DIR = INP_DIR_720;
197 vEncSample->DEFAULT_WIDTH = 1280;
198 vEncSample->DEFAULT_HEIGHT = 720;
199 vEncSample->DEFAULT_FRAME_RATE = 30;
200 vEncSample->enableForceIDR = true;
201 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
202 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
203 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
204 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
205 vEncSample->WaitForEOS();
206 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
207 } else {
208 return;
209 }
210 }
211
212 /**
213 * @tc.number : VIDEO_ENCODE_FUNCTION_0700
214 * @tc.name : set color format
215 * @tc.desc : function test
216 */
217 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0700, TestSize.Level1)
218 {
219 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
220 const int32_t *pixelFormat = nullptr;
221 uint32_t pixelFormatNum = 0;
222 if (cap) {
223 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixelFormat, &pixelFormatNum));
224 if (pixelFormatNum > 0) {
225 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
226 ASSERT_NE(nullptr, venc_);
227 format = OH_AVFormat_Create();
228 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_RANGE_FLAG, 1));
229 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_COLOR_PRIMARIES,
230 OH_ColorPrimary::COLOR_PRIMARY_BT709));
231 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_TRANSFER_CHARACTERISTICS,
232 OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_LINEAR));
233 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_MATRIX_COEFFICIENTS,
234 OH_MatrixCoefficient::MATRIX_COEFFICIENT_YCGCO));
235 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
236 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
237 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
238 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
239 }
240 } else {
241 return;
242 }
243 }
244
245 /**
246 * @tc.number : VIDEO_ENCODE_FUNCTION_0800
247 * @tc.name : set key frame interval avc
248 * @tc.desc : function test
249 */
250 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0800, TestSize.Level1)
251 {
252 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
253 const int32_t *pixelFormat = nullptr;
254 uint32_t pixelFormatNum = 0;
255 if (cap) {
256 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixelFormat, &pixelFormatNum));
257 if (pixelFormatNum > 0) {
258 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
259 ASSERT_NE(nullptr, venc_);
260 format = OH_AVFormat_Create();
261 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, SECOND));
262 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
263 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
264 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
265 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
266 OH_VideoEncoder_Destroy(venc_);
267 OH_AVFormat_Destroy(format);
268
269 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
270 ASSERT_NE(nullptr, venc_);
271 format = OH_AVFormat_Create();
272 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, -1));
273 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
274 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
275 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
276 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
277 OH_VideoEncoder_Destroy(venc_);
278 OH_AVFormat_Destroy(format);
279
280 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
281 ASSERT_NE(nullptr, venc_);
282 format = OH_AVFormat_Create();
283 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, 0));
284 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
285 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
286 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
287 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
288 OH_VideoEncoder_Destroy(venc_);
289 OH_AVFormat_Destroy(format);
290
291 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
292 ASSERT_NE(nullptr, venc_);
293 format = OH_AVFormat_Create();
294 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, INT_MAX));
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, pixelFormat[0]);
298 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
299 }
300 } else {
301 return;
302 }
303 }
304
305 /**
306 * @tc.number : VIDEO_ENCODE_FUNCTION_0810
307 * @tc.name : set key frame interval hevc
308 * @tc.desc : function test
309 */
310 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0810, TestSize.Level1)
311 {
312 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
313 if (cap) {
314 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
315 ASSERT_NE(nullptr, venc_);
316 format = OH_AVFormat_Create();
317 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, SECOND));
318 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
319 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
320 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
321 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
322 OH_VideoEncoder_Destroy(venc_);
323 OH_AVFormat_Destroy(format);
324
325 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
326 ASSERT_NE(nullptr, venc_);
327 format = OH_AVFormat_Create();
328 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, -1));
329 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
330 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
331 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
332 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
333 OH_VideoEncoder_Destroy(venc_);
334 OH_AVFormat_Destroy(format);
335
336 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
337 ASSERT_NE(nullptr, venc_);
338 format = OH_AVFormat_Create();
339 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, 0));
340 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
341 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
342 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
343 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
344 OH_VideoEncoder_Destroy(venc_);
345 OH_AVFormat_Destroy(format);
346
347 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
348 ASSERT_NE(nullptr, venc_);
349 format = OH_AVFormat_Create();
350 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, INT_MAX));
351 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
352 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
353 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
354 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
355 } else {
356 return;
357 }
358 }
359
360 /**
361 * @tc.number : VIDEO_ENCODE_FUNCTION_0900
362 * @tc.name : set profile level
363 * @tc.desc : function test
364 */
365 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0900, TestSize.Level1)
366 {
367 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
368 const int32_t *pixelFormat = nullptr;
369 uint32_t pixelFormatNum = 0;
370 if (cap) {
371 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixelFormat, &pixelFormatNum));
372 if (pixelFormatNum > 0) {
373 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
374 ASSERT_NE(nullptr, venc_);
375 format = OH_AVFormat_Create();
376 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_BASELINE);
377 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
378 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
379 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
380 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
381 OH_AVFormat_Destroy(format);
382 OH_VideoEncoder_Destroy(venc_);
383
384 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
385 ASSERT_NE(nullptr, venc_);
386 format = OH_AVFormat_Create();
387 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_HIGH);
388 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
389 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
390 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
391 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
392 OH_AVFormat_Destroy(format);
393 OH_VideoEncoder_Destroy(venc_);
394
395 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
396 ASSERT_NE(nullptr, venc_);
397 format = OH_AVFormat_Create();
398 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN);
399 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
400 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
401 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
402 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
403 OH_AVFormat_Destroy(format);
404 OH_VideoEncoder_Destroy(venc_);
405
406 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
407 ASSERT_NE(nullptr, venc_);
408 format = OH_AVFormat_Create();
409 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN + AVC_PROFILE_MAIN);
410 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
411 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
412 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
413 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
414 }
415 } else {
416 return;
417 }
418 }
419
420 /**
421 * @tc.number : VIDEO_ENCODE_FUNCTION_1000
422 * @tc.name : set bitrate mode
423 * @tc.desc : function test
424 */
425 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1000, TestSize.Level1)
426 {
427 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
428 const int32_t *pixelFormat = nullptr;
429 uint32_t pixelFormatNum = 0;
430 if (cap) {
431 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixelFormat, &pixelFormatNum));
432 if (pixelFormatNum > 0) {
433 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
434 ASSERT_NE(nullptr, venc_);
435 format = OH_AVFormat_Create();
436
437 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR));
438 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
439 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
440 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
441 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
442 }
443 } else {
444 return;
445 }
446 }
447
448 /**
449 * @tc.number : VIDEO_ENCODE_FUNCTION_1100
450 * @tc.name : set bitrate value
451 * @tc.desc : function test
452 */
453 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1100, TestSize.Level1)
454 {
455 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
456 const int32_t *pixelFormat = nullptr;
457 uint32_t pixelFormatNum = 0;
458 if (cap) {
459 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixelFormat, &pixelFormatNum));
460 if (pixelFormatNum > 0) {
461 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
462 ASSERT_NE(nullptr, venc_);
463 format = OH_AVFormat_Create();
464 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR));
465 ASSERT_EQ(true, OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 1000000));
466 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
467 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
468 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
469 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
470 }
471 } else {
472 return;
473 }
474 }
475
476 /**
477 * @tc.number : VIDEO_ENCODE_FUNCTION_1400
478 * @tc.name : set framerate
479 * @tc.desc : function test
480 */
481 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1400, TestSize.Level1)
482 {
483 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
484 const int32_t *pixelFormat = nullptr;
485 uint32_t pixelFormatNum = 0;
486 if (cap) {
487 ASSERT_EQ(AV_ERR_OK, OH_AVCapability_GetVideoSupportedPixelFormats(cap, &pixelFormat, &pixelFormatNum));
488 if (pixelFormatNum > 0) {
489 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
490 ASSERT_NE(nullptr, venc_);
491 format = OH_AVFormat_Create();
492
493 ASSERT_EQ(true, OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, 60));
494 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
495 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
496 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[0]);
497 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
498 }
499 } else {
500 return;
501 }
502 }
503
504 /**
505 * @tc.number : VIDEO_ENCODE_FUNCTION_1600
506 * @tc.name : set quality
507 * @tc.desc : function test
508 */
509 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1600, TestSize.Level1)
510 {
511 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
512 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
513 ASSERT_NE(nullptr, venc_);
514 format = OH_AVFormat_Create();
515 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CQ));
516 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, 60));
517 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
518 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
519 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
520 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
521 }
522 }
523
524 /**
525 * @tc.number : VIDEO_ENCODE_FUNCTION_1700
526 * @tc.name : input frame after EOS
527 * @tc.desc : function test
528 */
529 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1700, TestSize.Level1)
530 {
531 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
532 if (cap) {
533 auto vEncSample = make_unique<VEncNdkSample>();
534 vEncSample->INP_DIR = INP_DIR_720;
535 vEncSample->DEFAULT_WIDTH = 1280;
536 vEncSample->DEFAULT_HEIGHT = 720;
537 vEncSample->DEFAULT_FRAME_RATE = 30;
538 vEncSample->enable_random_eos = true;
539 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
540 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
541 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
542 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
543 vEncSample->WaitForEOS();
544 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
545 } else {
546 return;
547 }
548 }
549
550 /**
551 * @tc.number : VIDEO_ENCODE_FUNCTION_1800
552 * @tc.name : encode h265 buffer
553 * @tc.desc : function test
554 */
555 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1800, TestSize.Level1)
556 {
557 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
558 if (cap) {
559 auto vEncSample = make_unique<VEncNdkSample>();
560 vEncSample->INP_DIR = INP_DIR_720;
561 vEncSample->DEFAULT_WIDTH = 1280;
562 vEncSample->DEFAULT_HEIGHT = 720;
563 vEncSample->DEFAULT_FRAME_RATE = 30;
564 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
565 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
566 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
567 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
568 vEncSample->WaitForEOS();
569 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
570 } else {
571 return;
572 }
573 }
574
575 /**
576 * @tc.number : VIDEO_ENCODE_FUNCTION_2000
577 * @tc.name : encode RGBA h265 buffer mode
578 * @tc.desc : function test
579 */
580 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_2000, TestSize.Level1)
581 {
582 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
583 if (cap) {
584 auto vEncSample = make_unique<VEncNdkSample>();
585 vEncSample->INP_DIR = "/data/test/media/test.rgba";
586 vEncSample->DEFAULT_WIDTH = 1280;
587 vEncSample->DEFAULT_HEIGHT = 720;
588 vEncSample->DEFAULT_FRAME_RATE = 30;
589 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA;
590 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
591 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
592 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
593 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
594 vEncSample->WaitForEOS();
595 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
596 } else {
597 return;
598 }
599 }
600
601 /**
602 * @tc.number : VIDEO_ENCODE_FUNCTION_1900
603 * @tc.name : encode h265 surface
604 * @tc.desc : function test
605 */
606 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1900, TestSize.Level1)
607 {
608 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
609 if (cap) {
610 auto vEncSample = make_unique<VEncNdkSample>();
611 vEncSample->INP_DIR = INP_DIR_720;
612 vEncSample->DEFAULT_WIDTH = 1280;
613 vEncSample->DEFAULT_HEIGHT = 720;
614 vEncSample->DEFAULT_FRAME_RATE = 30;
615 vEncSample->SURF_INPUT = true;
616 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
617 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
618 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
619 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
620 vEncSample->WaitForEOS();
621 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
622 } else {
623 return;
624 }
625 }
626
627 /**
628 * @tc.number : VIDEO_ENCODE_CAPABILITY_0100
629 * @tc.name : OH_AVCodec_GetCapability para error
630 * @tc.desc : api test
631 */
632 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0100, TestSize.Level2)
633 {
634 const char *p = nullptr;
635 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability(p, true));
636 }
637
638 /**
639 * @tc.number : VIDEO_ENCODE_CAPABILITY_0200
640 * @tc.name : OH_AVCodec_GetCapability para error
641 * @tc.desc : api test
642 */
643 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0200, TestSize.Level2)
644 {
645 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability("", true));
646 }
647
648 /**
649 * @tc.number : VIDEO_ENCODE_CAPABILITY_0300
650 * @tc.name : OH_AVCodec_GetCapability para error
651 * @tc.desc : api test
652 */
653 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0300, TestSize.Level2)
654 {
655 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability("notexist", true));
656 }
657
658 /**
659 * @tc.number : VIDEO_ENCODE_CAPABILITY_0400
660 * @tc.name : OH_AVCodec_GetCapability
661 * @tc.desc : api test
662 */
663 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0400, TestSize.Level2)
664 {
665 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
666 if (cap) {
667 ASSERT_NE(nullptr, OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true));
668 } else {
669 return;
670 }
671 }
672
673 /**
674 * @tc.number : VIDEO_ENCODE_CAPABILITY_0500
675 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
676 * @tc.desc : api test
677 */
678 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0500, TestSize.Level2)
679 {
680 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory("", true, HARDWARE));
681 }
682 /**
683 * @tc.number : VIDEO_ENCODE_CAPABILITY_9900
684 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
685 * @tc.desc : api test
686 */
687 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_9900, TestSize.Level2)
688 {
689 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory(nullptr, true, HARDWARE));
690 }
691
692 /**
693 * @tc.number : VIDEO_ENCODE_CAPABILITY_0600
694 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
695 * @tc.desc : api test
696 */
697 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0600, TestSize.Level2)
698 {
699 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory("notexist", true, HARDWARE));
700 }
701
702 /**
703 * @tc.number : VIDEO_ENCODE_CAPABILITY_0700
704 * @tc.name : OH_AVCodec_GetCapabilityByCategory param correct
705 * @tc.desc : api test
706 */
707 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0700, TestSize.Level2)
708 {
709 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
710 if (cap) {
711 ASSERT_NE(nullptr, OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE));
712 } else {
713 return;
714 }
715 }
716
717 /**
718 * @tc.number : VIDEO_ENCODE_CAPABILITY_0800
719 * @tc.name : OH_AVCapability_IsHardware param error
720 * @tc.desc : api test
721 */
722 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0800, TestSize.Level2)
723 {
724 ASSERT_EQ(false, OH_AVCapability_IsHardware(nullptr));
725 }
726
727 /**
728 * @tc.number : VIDEO_ENCODE_CAPABILITY_0900
729 * @tc.name : OH_AVCapability_IsHardware param correct
730 * @tc.desc : api test
731 */
732 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0900, TestSize.Level2)
733 {
734 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
735 if (cap) {
736 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
737 ASSERT_NE(nullptr, capability);
738 ASSERT_EQ(true, OH_AVCapability_IsHardware(capability));
739 } else {
740 return;
741 }
742 }
743
744 /**
745 * @tc.number : VIDEO_ENCODE_CAPABILITY_1000
746 * @tc.name : OH_AVCapability_GetName param error
747 * @tc.desc : api test
748 */
749 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1000, TestSize.Level2)
750 {
751 const char *name = OH_AVCapability_GetName(nullptr);
752 ASSERT_NE(name, nullptr);
753 ASSERT_EQ(strlen(name), 0);
754 }
755
756 /**
757 * @tc.number : VIDEO_ENCODE_CAPABILITY_1100
758 * @tc.name : OH_AVCapability_GetName param correct
759 * @tc.desc : api test
760 */
761 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1100, TestSize.Level2)
762 {
763 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
764 if (cap) {
765 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
766 ASSERT_NE(nullptr, capability);
767 const char *name = OH_AVCapability_GetName(capability);
768 ASSERT_NE(name, nullptr);
769 ASSERT_GT(strlen(name), 0);
770 } else {
771 return;
772 }
773 }
774
775 /**
776 * @tc.number : VIDEO_ENCODE_CAPABILITY_1200
777 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param error
778 * @tc.desc : api test
779 */
780 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1200, TestSize.Level2)
781 {
782 int32_t maxSupportedInstance = OH_AVCapability_GetMaxSupportedInstances(nullptr);
783 ASSERT_EQ(maxSupportedInstance, 0);
784 }
785
786 /**
787 * @tc.number : VIDEO_ENCODE_CAPABILITY_1300
788 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param correct
789 * @tc.desc : api test
790 */
791 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1300, TestSize.Level2)
792 {
793 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
794 if (cap) {
795 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
796 ASSERT_NE(nullptr, capability);
797
798 string codecName = OH_AVCapability_GetName(capability);
799 if (codecName == "OMX.hisi.video.encoder.avc") {
800 ASSERT_EQ(16, OH_AVCapability_GetMaxSupportedInstances(capability));
801 } else {
802 ASSERT_EQ(4, OH_AVCapability_GetMaxSupportedInstances(capability));
803 }
804 } else {
805 return;
806 }
807 }
808
809 /**
810 * @tc.number : VIDEO_ENCODE_CAPABILITY_1310
811 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param correct
812 * @tc.desc : api test
813 */
814 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1310, TestSize.Level2)
815 {
816 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
817 if (cap) {
818 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
819 ASSERT_NE(nullptr, capability);
820
821 string codecName = OH_AVCapability_GetName(capability);
822 if (codecName == "OMX.hisi.video.encoder.hevc") {
823 ASSERT_EQ(16, OH_AVCapability_GetMaxSupportedInstances(capability));
824 } else {
825 ASSERT_EQ(4, OH_AVCapability_GetMaxSupportedInstances(capability));
826 }
827 } else {
828 return;
829 }
830 }
831
832 /**
833 * @tc.number : VIDEO_ENCODE_CAPABILITY_1400
834 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
835 * @tc.desc : api test
836 */
837 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1400, TestSize.Level2)
838 {
839 OH_AVErrCode ret = AV_ERR_OK;
840 OH_AVRange range;
841 ret = OH_AVCapability_GetEncoderBitrateRange(nullptr, &range);
842 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
843 }
844
845 /**
846 * @tc.number : VIDEO_ENCODE_CAPABILITY_1500
847 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
848 * @tc.desc : api test
849 */
850
851 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1500, TestSize.Level2)
852 {
853 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
854 if (cap) {
855 OH_AVErrCode ret = AV_ERR_OK;
856
857 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
858 ASSERT_NE(nullptr, capability);
859
860 ret = OH_AVCapability_GetEncoderBitrateRange(capability, nullptr);
861 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
862 } else {
863 return;
864 }
865 }
866
867 /**
868 * @tc.number : VIDEO_ENCODE_CAPABILITY_1700
869 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param correct
870 * @tc.desc : api test
871 */
872 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1700, TestSize.Level2)
873 {
874 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
875 if (cap) {
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, HARDWARE);
880 ASSERT_NE(nullptr, capability);
881 ret = OH_AVCapability_GetEncoderBitrateRange(capability, &range);
882 ASSERT_EQ(AV_ERR_OK, ret);
883 cout << "max val " << range.maxVal << " min val " << range.minVal << endl;
884 ASSERT_GE(range.minVal, 0);
885 ASSERT_GT(range.maxVal, 0);
886 } else {
887 return;
888 }
889 }
890
891 /**
892 * @tc.number : VIDEO_ENCODE_CAPABILITY_1800
893 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param error
894 * @tc.desc : api test
895 */
896 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1800, TestSize.Level2)
897 {
898 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(nullptr, BITRATE_MODE_CBR);
899 ASSERT_EQ(false, isSupported);
900 }
901
902 /**
903 * @tc.number : VIDEO_ENCODE_CAPABILITY_1900
904 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
905 * @tc.desc : api test
906 */
907 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1900, TestSize.Level2)
908 {
909 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
910 if (cap) {
911 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
912 ASSERT_NE(nullptr, capability);
913 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
914 ASSERT_NE(nullptr, venc_);
915 format = OH_AVFormat_Create();
916 ASSERT_NE(nullptr, format);
917 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
918 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
919 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
920 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
921 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
922
923 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_CBR);
924 EXPECT_EQ(isSupported, true);
925 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CBR);
926 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
927 } else {
928 return;
929 }
930 }
931
932 /**
933 * @tc.number : VIDEO_ENCODE_CAPABILITY_8400
934 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
935 * @tc.desc : api test
936 */
937 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8400, TestSize.Level2)
938 {
939 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
940 if (cap) {
941 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
942 ASSERT_NE(nullptr, capability);
943 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
944 ASSERT_NE(nullptr, venc_);
945 format = OH_AVFormat_Create();
946 ASSERT_NE(nullptr, format);
947 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
948 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
949 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
950 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
951 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
952
953 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_VBR);
954 EXPECT_EQ(isSupported, true);
955 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_VBR);
956 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
957 } else {
958 return;
959 }
960 }
961
962 /**
963 * @tc.number : VIDEO_ENCODE_CAPABILITY_8500
964 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
965 * @tc.desc : api test
966 */
967 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8500, TestSize.Level2)
968 {
969 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
970 if (cap) {
971 OH_AVCapability *capa = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
972 ASSERT_NE(nullptr, capa);
973 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
974 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
975 ASSERT_NE(nullptr, venc_);
976 format = OH_AVFormat_Create();
977 ASSERT_NE(nullptr, format);
978 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
979 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
980 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
981 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
982 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, DEFAULT_QUALITY);
983 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
984 EXPECT_EQ(isSupported, true);
985 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CQ);
986 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
987 } else {
988 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
989 EXPECT_EQ(isSupported, false);
990 }
991 } else {
992 return;
993 }
994 }
995
996 /**
997 * @tc.number : VIDEO_ENCODE_CAPABILITY_8600
998 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
999 * @tc.desc : api test
1000 */
1001 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8600, TestSize.Level2)
1002 {
1003 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1004 if (cap) {
1005 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1006 ASSERT_NE(nullptr, capability);
1007 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1008 ASSERT_NE(nullptr, venc_);
1009 format = OH_AVFormat_Create();
1010 ASSERT_NE(nullptr, format);
1011 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1012 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1013 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1014 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1015 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1016
1017 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, NO_SUPPORT_MODE);
1018 EXPECT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
1019 } else {
1020 return;
1021 }
1022 }
1023
1024 /**
1025 * @tc.number : VIDEO_ENCODE_CAPABILITY_2000
1026 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
1027 * @tc.desc : api test
1028 */
1029 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2000, TestSize.Level2)
1030 {
1031 OH_AVErrCode ret = AV_ERR_OK;
1032 OH_AVRange range;
1033 ret = OH_AVCapability_GetEncoderQualityRange(nullptr, &range);
1034 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1035 }
1036
1037 /**
1038 * @tc.number : VIDEO_ENCODE_CAPABILITY_2100
1039 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
1040 * @tc.desc : api test
1041 */
1042 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2100, TestSize.Level2)
1043 {
1044 OH_AVErrCode ret = AV_ERR_OK;
1045 ret = OH_AVCapability_GetEncoderQualityRange(nullptr, nullptr);
1046 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1047 }
1048
1049 /**
1050 * @tc.number : VIDEO_ENCODE_CAPABILITY_2200
1051 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
1052 * @tc.desc : api test
1053 */
1054 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2200, TestSize.Level2)
1055 {
1056 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1057 if (cap) {
1058 OH_AVErrCode ret = AV_ERR_OK;
1059 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1060 ASSERT_NE(nullptr, capability);
1061 ret = OH_AVCapability_GetEncoderQualityRange(capability, nullptr);
1062 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1063 } else {
1064 return;
1065 }
1066 }
1067
1068 /**
1069 * @tc.number : VIDEO_ENCODE_CAPABILITY_2300
1070 * @tc.name : OH_AVCapability_GetEncoderQualityRange param correct
1071 * @tc.desc : api test
1072 */
1073 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2300, TestSize.Level2)
1074 {
1075 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1076 if (cap) {
1077 OH_AVErrCode ret = AV_ERR_OK;
1078 OH_AVRange range;
1079 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1080 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1081 ASSERT_NE(nullptr, capability);
1082 ret = OH_AVCapability_GetEncoderQualityRange(capability, &range);
1083 ASSERT_EQ(AV_ERR_OK, ret);
1084 ASSERT_EQ(range.minVal, 0);
1085 ASSERT_EQ(range.maxVal, MAX_QUALITY);
1086 } else {
1087 return;
1088 }
1089 }
1090
1091 /**
1092 * @tc.number : VIDEO_ENCODE_CAPABILITY_2400
1093 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
1094 * @tc.desc : api test
1095 */
1096 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2400, TestSize.Level2)
1097 {
1098 OH_AVErrCode ret = AV_ERR_OK;
1099 ret = OH_AVCapability_GetEncoderComplexityRange(nullptr, nullptr);
1100 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1101 }
1102
1103 /**
1104 * @tc.number : VIDEO_ENCODE_CAPABILITY_2500
1105 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
1106 * @tc.desc : api test
1107 */
1108 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2500, TestSize.Level2)
1109 {
1110 OH_AVErrCode ret = AV_ERR_OK;
1111 OH_AVRange range;
1112 ret = OH_AVCapability_GetEncoderComplexityRange(nullptr, &range);
1113 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1114 }
1115
1116 /**
1117 * @tc.number : VIDEO_ENCODE_CAPABILITY_2700
1118 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
1119 * @tc.desc : api test
1120 */
1121 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2700, TestSize.Level2)
1122 {
1123 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1124 if (cap) {
1125 OH_AVErrCode ret = AV_ERR_OK;
1126 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1127 ASSERT_NE(nullptr, capability);
1128 ret = OH_AVCapability_GetEncoderComplexityRange(capability, nullptr);
1129 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1130 } else {
1131 return;
1132 }
1133 }
1134
1135 /**
1136 * @tc.number : VIDEO_ENCODE_CAPABILITY_2800
1137 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param correct
1138 * @tc.desc : api test
1139 */
1140 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2800, TestSize.Level2)
1141 {
1142 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1143 if (cap) {
1144 OH_AVErrCode ret = AV_ERR_OK;
1145 OH_AVRange range;
1146 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1147 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1148 ASSERT_NE(nullptr, capability);
1149 ret = OH_AVCapability_GetEncoderComplexityRange(capability, &range);
1150 ASSERT_EQ(AV_ERR_OK, ret);
1151 } else {
1152 return;
1153 }
1154 }
1155
1156 /**
1157 * @tc.number : VIDEO_ENCODE_CAPABILITY_3100
1158 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
1159 * @tc.desc : api test
1160 */
1161 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3100, TestSize.Level2)
1162 {
1163 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1164 if (cap) {
1165 OH_AVErrCode ret = AV_ERR_OK;
1166 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1167 ASSERT_NE(nullptr, capability);
1168 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
1169 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1170 } else {
1171 return;
1172 }
1173 }
1174
1175 /**
1176 * @tc.number : VIDEO_ENCODE_CAPABILITY_3200
1177 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
1178 * @tc.desc : api test
1179 */
1180 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3200, TestSize.Level2)
1181 {
1182 OH_AVErrCode ret = AV_ERR_OK;
1183 int32_t alignment = 0;
1184 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
1185 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1186 }
1187
1188 /**
1189 * @tc.number : VIDEO_ENCODE_CAPABILITY_3300
1190 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
1191 * @tc.desc : api test
1192 */
1193 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3300, TestSize.Level2)
1194 {
1195 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1196 if (cap) {
1197 OH_AVErrCode ret = AV_ERR_OK;
1198 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1199 ASSERT_NE(nullptr, capability);
1200 int32_t alignment = 0;
1201 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
1202 ASSERT_EQ(AV_ERR_OK, ret);
1203 ASSERT_GE(alignment, 0);
1204 } else {
1205 return;
1206 }
1207 }
1208
1209 /**
1210 * @tc.number : VIDEO_ENCODE_CAPABILITY_3400
1211 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1212 * @tc.desc : api test
1213 */
1214 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3400, TestSize.Level2)
1215 {
1216 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1217 if (cap) {
1218 OH_AVErrCode ret = AV_ERR_OK;
1219 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1220 ASSERT_NE(nullptr, capability);
1221 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
1222 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1223 } else {
1224 return;
1225 }
1226 }
1227
1228 /**
1229 * @tc.number : VIDEO_ENCODE_CAPABILITY_3500
1230 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1231 * @tc.desc : api test
1232 */
1233 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3500, TestSize.Level2)
1234 {
1235 OH_AVErrCode ret = AV_ERR_OK;
1236 int32_t alignment = 0;
1237 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
1238 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1239 }
1240
1241 /**
1242 * @tc.number : VIDEO_ENCODE_CAPABILITY_3600
1243 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
1244 * @tc.desc : api test
1245 */
1246 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3600, TestSize.Level2)
1247 {
1248 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1249 if (cap) {
1250 OH_AVErrCode ret = AV_ERR_OK;
1251 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1252 ASSERT_NE(nullptr, capability);
1253 int32_t alignment = 0;
1254 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
1255 ASSERT_EQ(AV_ERR_OK, ret);
1256 ASSERT_GE(alignment, 0);
1257 } else {
1258 return;
1259 }
1260 }
1261
1262 /**
1263 * @tc.number : VIDEO_ENCODE_CAPABILITY_3700
1264 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1265 * @tc.desc : api test
1266 */
1267 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3700, TestSize.Level2)
1268 {
1269 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1270 if (cap) {
1271 OH_AVErrCode ret = AV_ERR_OK;
1272 OH_AVRange range;
1273 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1274 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1275 ASSERT_NE(nullptr, capability);
1276 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_WIDTH, &range);
1277 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1278 } else {
1279 return;
1280 }
1281 }
1282
1283 /**
1284 * @tc.number : VIDEO_ENCODE_CAPABILITY_3800
1285 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1286 * @tc.desc : api test
1287 */
1288 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3800, TestSize.Level2)
1289 {
1290 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1291 if (cap) {
1292 OH_AVErrCode ret = AV_ERR_OK;
1293 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1294 ASSERT_NE(nullptr, capability);
1295 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_WIDTH, nullptr);
1296 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1297 } else {
1298 return;
1299 }
1300 }
1301
1302 /**
1303 * @tc.number : VIDEO_ENCODE_CAPABILITY_3900
1304 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1305 * @tc.desc : api test
1306 */
1307 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3900, TestSize.Level2)
1308 {
1309 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1310 if (cap) {
1311 OH_AVErrCode ret = AV_ERR_OK;
1312 OH_AVRange range;
1313 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1314 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1315 ASSERT_NE(nullptr, capability);
1316 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
1317 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1318 } else {
1319 return;
1320 }
1321 }
1322
1323 /**
1324 * @tc.number : VIDEO_ENCODE_CAPABILITY_4100
1325 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1326 * @tc.desc : api test
1327 */
1328 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4100, TestSize.Level2)
1329 {
1330 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1331 if (cap) {
1332 OH_AVErrCode ret = AV_ERR_OK;
1333 OH_AVRange range;
1334 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1335 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1336 ASSERT_NE(nullptr, capability);
1337 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_HEIGHT, &range);
1338 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1339 } else {
1340 return;
1341 }
1342 }
1343
1344 /**
1345 * @tc.number : VIDEO_ENCODE_CAPABILITY_4200
1346 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1347 * @tc.desc : api test
1348 */
1349 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4200, TestSize.Level2)
1350 {
1351 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1352 if (cap) {
1353 OH_AVErrCode ret = AV_ERR_OK;
1354 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1355 ASSERT_NE(nullptr, capability);
1356 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_HEIGHT, nullptr);
1357 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1358 } else {
1359 return;
1360 }
1361 }
1362
1363 /**
1364 * @tc.number : VIDEO_ENCODE_CAPABILITY_4300
1365 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1366 * @tc.desc : api test
1367 */
1368 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4300, TestSize.Level2)
1369 {
1370 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1371 if (cap) {
1372 OH_AVErrCode ret = AV_ERR_OK;
1373 OH_AVRange range;
1374 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1375 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1376 ASSERT_NE(nullptr, capability);
1377 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
1378 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1379 } else {
1380 return;
1381 }
1382 }
1383
1384 /**
1385 * @tc.number : VIDEO_ENCODE_CAPABILITY_4500
1386 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1387 * @tc.desc : api test
1388 */
1389 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4500, TestSize.Level2)
1390 {
1391 OH_AVErrCode ret = AV_ERR_OK;
1392 OH_AVRange range;
1393 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1394 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1395 }
1396
1397 /**
1398 * @tc.number : VIDEO_ENCODE_CAPABILITY_4600
1399 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1400 * @tc.desc : api test
1401 */
1402 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4600, TestSize.Level2)
1403 {
1404 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1405 if (cap) {
1406 OH_AVErrCode ret = AV_ERR_OK;
1407 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1408 ASSERT_NE(nullptr, capability);
1409 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1410 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1411 } else {
1412 return;
1413 }
1414 }
1415
1416 /**
1417 * @tc.number : VIDEO_ENCODE_CAPABILITY_4800
1418 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1419 * @tc.desc : api test
1420 */
1421 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4800, TestSize.Level2)
1422 {
1423 OH_AVErrCode ret = AV_ERR_OK;
1424 OH_AVRange range;
1425 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1426 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1427 }
1428
1429 /**
1430 * @tc.number : VIDEO_ENCODE_CAPABILITY_4900
1431 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1432 * @tc.desc : api test
1433 */
1434 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4900, TestSize.Level2)
1435 {
1436 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1437 if (cap) {
1438 OH_AVErrCode ret = AV_ERR_OK;
1439 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1440 ASSERT_NE(nullptr, capability);
1441 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1442 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1443 } else {
1444 return;
1445 }
1446 }
1447
1448 /**
1449 * @tc.number : VIDEO_ENCODE_CAPABILITY_9800
1450 * @tc.name : configure encoder with illegal width and height
1451 * @tc.desc : api test
1452 */
1453 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_9800, TestSize.Level2)
1454 {
1455 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1456 if (cap) {
1457 OH_AVErrCode ret = AV_ERR_OK;
1458 OH_AVRange widthRange;
1459 OH_AVRange heightRange;
1460 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1461 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1462 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1463 ASSERT_NE(nullptr, capability);
1464 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1465 ASSERT_EQ(AV_ERR_OK, ret);
1466 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1467 ASSERT_EQ(AV_ERR_OK, ret);
1468 } else {
1469 return;
1470 }
1471 }
1472
1473 /**
1474 * @tc.number : VIDEO_ENCODE_CAPABILITY_5100
1475 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1476 * @tc.desc : api test
1477 */
1478 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5100, TestSize.Level2)
1479 {
1480 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1481 if (cap) {
1482 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1483 ASSERT_NE(nullptr, capability);
1484 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1485 } else {
1486 return;
1487 }
1488 }
1489
1490 /**
1491 * @tc.number : VIDEO_ENCODE_CAPABILITY_5200
1492 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1493 * @tc.desc : api test
1494 */
1495 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5200, TestSize.Level2)
1496 {
1497 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1498 if (cap) {
1499 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1500 ASSERT_NE(nullptr, capability);
1501 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1502 } else {
1503 return;
1504 }
1505 }
1506
1507 /**
1508 * @tc.number : VIDEO_ENCODE_CAPABILITY_5300
1509 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1510 * @tc.desc : api test
1511 */
1512 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5300, TestSize.Level2)
1513 {
1514 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1515 }
1516
1517 /**
1518 * @tc.number : VIDEO_ENCODE_CAPABILITY_5400
1519 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1520 * @tc.desc : api test
1521 */
1522 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5400, TestSize.Level2)
1523 {
1524 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1525 if (cap) {
1526 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1527 ASSERT_NE(nullptr, capability);
1528 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1529 } else {
1530 return;
1531 }
1532 }
1533
1534 /**
1535 * @tc.number : VIDEO_ENCODE_CAPABILITY_5500
1536 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1537 * @tc.desc : api test
1538 */
1539 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5500, TestSize.Level2)
1540 {
1541 OH_AVErrCode ret = AV_ERR_OK;
1542 OH_AVRange range;
1543 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1544 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1545 }
1546
1547 /**
1548 * @tc.number : VIDEO_ENCODE_CAPABILITY_5600
1549 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1550 * @tc.desc : api test
1551 */
1552 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5600, TestSize.Level2)
1553 {
1554 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1555 if (cap) {
1556 OH_AVErrCode ret = AV_ERR_OK;
1557 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1558 ASSERT_NE(nullptr, capability);
1559 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1560 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1561 } else {
1562 return;
1563 }
1564 }
1565
1566 /**
1567 * @tc.number : VIDEO_ENCODE_CAPABILITY_5700
1568 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1569 * @tc.desc : api test
1570 */
1571 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5700, TestSize.Level2)
1572 {
1573 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1574 if (cap) {
1575 OH_AVErrCode ret = AV_ERR_OK;
1576 OH_AVRange range;
1577 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1578 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1579 ASSERT_NE(nullptr, capability);
1580 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1581 ASSERT_EQ(AV_ERR_OK, ret);
1582 ASSERT_GT(range.minVal, 0);
1583 ASSERT_GT(range.maxVal, 0);
1584 } else {
1585 return;
1586 }
1587 }
1588
1589 /**
1590 * @tc.number : VIDEO_ENCODE_CAPABILITY_5800
1591 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1592 * @tc.desc : api test
1593 */
1594 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5800, TestSize.Level2)
1595 {
1596 OH_AVErrCode ret = AV_ERR_OK;
1597 OH_AVRange range;
1598 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1599 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1600 }
1601
1602 /**
1603 * @tc.number : VIDEO_ENCODE_CAPABILITY_5900
1604 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1605 * @tc.desc : api test
1606 */
1607 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5900, TestSize.Level2)
1608 {
1609 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1610 if (cap) {
1611 OH_AVErrCode ret = AV_ERR_OK;
1612 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1613 ASSERT_NE(nullptr, capability);
1614 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1615 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1616 } else {
1617 return;
1618 }
1619 }
1620
1621 /**
1622 * @tc.number : VIDEO_ENCODE_CAPABILITY_6000
1623 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1624 * @tc.desc : api test
1625 */
1626 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6000, TestSize.Level2)
1627 {
1628 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1629 if (cap) {
1630 OH_AVErrCode ret = AV_ERR_OK;
1631 OH_AVRange range;
1632 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1633 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1634 ASSERT_NE(nullptr, capability);
1635 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1636 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1637 } else {
1638 return;
1639 }
1640 }
1641
1642 /**
1643 * @tc.number : VIDEO_ENCODE_CAPABILITY_6100
1644 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1645 * @tc.desc : api test
1646 */
1647 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6100, TestSize.Level2)
1648 {
1649 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1650 if (cap) {
1651 OH_AVErrCode ret = AV_ERR_OK;
1652 OH_AVRange range;
1653 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1654 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1655 ASSERT_NE(nullptr, capability);
1656 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1657 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1658 } else {
1659 return;
1660 }
1661 }
1662
1663 /**
1664 * @tc.number : VIDEO_ENCODE_CAPABILITY_6200
1665 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1666 * @tc.desc : api test
1667 */
1668 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6200, TestSize.Level2)
1669 {
1670 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1671 if (cap) {
1672 OH_AVErrCode ret = AV_ERR_OK;
1673 OH_AVRange range;
1674 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1675 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1676 ASSERT_NE(nullptr, capability);
1677 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1678 ASSERT_EQ(AV_ERR_OK, ret);
1679 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1680 ASSERT_GT(range.minVal, 0);
1681 ASSERT_GT(range.maxVal, 0);
1682 } else {
1683 return;
1684 }
1685 }
1686
1687 /**
1688 * @tc.number : VIDEO_ENCODE_CAPABILITY_6300
1689 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1690 * @tc.desc : api test
1691 */
1692 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6300, TestSize.Level2)
1693 {
1694 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1695 if (cap) {
1696 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1697 ASSERT_NE(nullptr, capability);
1698 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1699 } else {
1700 return;
1701 }
1702 }
1703
1704 /**
1705 * @tc.number : VIDEO_ENCODE_CAPABILITY_6400
1706 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1707 * @tc.desc : api test
1708 */
1709 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6400, TestSize.Level2)
1710 {
1711 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1712 if (cap) {
1713 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1714 ASSERT_NE(nullptr, capability);
1715 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1716 } else {
1717 return;
1718 }
1719 }
1720
1721 /**
1722 * @tc.number : VIDEO_ENCODE_CAPABILITY_6500
1723 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1724 * @tc.desc : api test
1725 */
1726 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6500, TestSize.Level2)
1727 {
1728 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1729 if (cap) {
1730 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1731 ASSERT_NE(nullptr, capability);
1732 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1733 } else {
1734 return;
1735 }
1736 }
1737
1738 /**
1739 * @tc.number : VIDEO_ENCODE_CAPABILITY_6600
1740 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1741 * @tc.desc : api test
1742 */
1743 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6600, TestSize.Level2)
1744 {
1745 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1746 }
1747
1748 /**
1749 * @tc.number : VIDEO_ENCODE_CAPABILITY_6700
1750 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1751 * @tc.desc : api test
1752 */
1753 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6700, TestSize.Level2)
1754 {
1755 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1756 if (cap) {
1757 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1758 ASSERT_NE(nullptr, capability);
1759 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1760 } else {
1761 return;
1762 }
1763 }
1764
1765 /**
1766 * @tc.number : VIDEO_ENCODE_CAPABILITY_6800
1767 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1768 * @tc.desc : api test
1769 */
1770 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6800, TestSize.Level2)
1771 {
1772 OH_AVErrCode ret = AV_ERR_OK;
1773 const int32_t *pixelFormat = nullptr;
1774 uint32_t pixelFormatNum = 0;
1775 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1776 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1777 }
1778
1779 /**
1780 * @tc.number : VIDEO_ENCODE_CAPABILITY_6900
1781 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1782 * @tc.desc : api test
1783 */
1784 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6900, TestSize.Level2)
1785 {
1786 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1787 if (cap) {
1788 OH_AVErrCode ret = AV_ERR_OK;
1789 uint32_t pixelFormatNum = 0;
1790 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1791 ASSERT_NE(nullptr, capability);
1792 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1793 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1794 } else {
1795 return;
1796 }
1797 }
1798
1799 /**
1800 * @tc.number : VIDEO_ENCODE_CAPABILITY_7000
1801 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1802 * @tc.desc : api test
1803 */
1804 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7000, TestSize.Level2)
1805 {
1806 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1807 if (cap) {
1808 OH_AVErrCode ret = AV_ERR_OK;
1809 const int32_t *pixelFormat = nullptr;
1810 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1811 ASSERT_NE(nullptr, capability);
1812 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1813 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1814 } else {
1815 return;
1816 }
1817 }
1818
1819 /**
1820 * @tc.number : VIDEO_ENCODE_CAPABILITY_7100
1821 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1822 * @tc.desc : api test
1823 */
1824 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7100, TestSize.Level2)
1825 {
1826 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1827 if (cap) {
1828 OH_AVErrCode ret = AV_ERR_OK;
1829 const int32_t *pixelFormat = nullptr;
1830 uint32_t pixelFormatNum = 0;
1831 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1832 ASSERT_NE(nullptr, capability);
1833 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1834 ASSERT_NE(nullptr, pixelFormat);
1835 ASSERT_GT(pixelFormatNum, 0);
1836 ASSERT_EQ(AV_ERR_OK, ret);
1837 for (int i = 0; i < pixelFormatNum; i++) {
1838 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1839 ASSERT_NE(nullptr, venc_);
1840 format = OH_AVFormat_Create();
1841 ASSERT_NE(nullptr, format);
1842 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1843 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1844 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1845 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1846 EXPECT_GE(pixelFormat[i], 0);
1847 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1848 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1849 OH_AVFormat_Destroy(format);
1850 OH_VideoEncoder_Destroy(venc_);
1851 }
1852 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1853 ASSERT_NE(nullptr, venc_);
1854 format = OH_AVFormat_Create();
1855 ASSERT_NE(nullptr, format);
1856 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1857 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1858 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1859 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1860 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1861 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoEncoder_Configure(venc_, format));
1862 } else {
1863 return;
1864 }
1865 }
1866
1867 /**
1868 * @tc.number : VIDEO_ENCODE_CAPABILITY_7200
1869 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1870 * @tc.desc : api test
1871 */
1872 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7200, TestSize.Level2)
1873 {
1874 OH_AVErrCode ret = AV_ERR_OK;
1875 const int32_t *profiles = nullptr;
1876 uint32_t profileNum = 0;
1877 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
1878 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1879 }
1880
1881 /**
1882 * @tc.number : VIDEO_ENCODE_CAPABILITY_7300
1883 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1884 * @tc.desc : api test
1885 */
1886 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7300, TestSize.Level2)
1887 {
1888 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1889 if (cap) {
1890 OH_AVErrCode ret = AV_ERR_OK;
1891 uint32_t profileNum = 0;
1892 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1893 ASSERT_NE(nullptr, capability);
1894 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
1895 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1896 } else {
1897 return;
1898 }
1899 }
1900
1901 /**
1902 * @tc.number : VIDEO_ENCODE_CAPABILITY_7400
1903 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1904 * @tc.desc : api test
1905 */
1906 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7400, TestSize.Level2)
1907 {
1908 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1909 if (cap) {
1910 OH_AVErrCode ret = AV_ERR_OK;
1911 const int32_t *profiles = nullptr;
1912 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1913 ASSERT_NE(nullptr, capability);
1914 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
1915 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1916 } else {
1917 return;
1918 }
1919 }
1920
1921 /**
1922 * @tc.number : VIDEO_ENCODE_CAPABILITY_7500
1923 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1924 * @tc.desc : api test
1925 */
1926 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7500, TestSize.Level2)
1927 {
1928 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1929 if (cap) {
1930 OH_AVErrCode ret = AV_ERR_OK;
1931 const int32_t *profiles = nullptr;
1932 uint32_t profileNum = 0;
1933 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1934 ASSERT_NE(nullptr, capability);
1935 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1936 ASSERT_EQ(AV_ERR_OK, ret);
1937 ASSERT_NE(nullptr, profiles);
1938 ASSERT_EQ(profileNum, MAX_PROFILE_NUM);
1939 for (int i = 0; i < profileNum; i++) {
1940 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1941 ASSERT_NE(nullptr, venc_);
1942 format = OH_AVFormat_Create();
1943 ASSERT_NE(nullptr, format);
1944 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1945 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1946 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1947 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1948 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1949 EXPECT_GE(profiles[i], 0);
1950 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, profiles[i]);
1951 ret = OH_VideoEncoder_Configure(venc_, format);
1952 if (ret != AV_ERR_OK) {
1953 cout << profiles[i] << " profile cant configure" << endl;
1954 }
1955 EXPECT_EQ(AV_ERR_OK, ret);
1956 OH_AVFormat_Destroy(format);
1957 OH_VideoEncoder_Destroy(venc_);
1958 }
1959 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1960 ASSERT_NE(nullptr, venc_);
1961 format = OH_AVFormat_Create();
1962 ASSERT_NE(nullptr, format);
1963 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1964 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1965 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1966 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1967 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1968 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN + AVC_PROFILE_MAIN);
1969 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
1970 } else {
1971 return;
1972 }
1973 }
1974
1975 /**
1976 * @tc.number : VIDEO_ENCODE_CAPABILITY_7600
1977 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1978 * @tc.desc : api test
1979 */
1980 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7600, TestSize.Level2)
1981 {
1982 OH_AVErrCode ret = AV_ERR_OK;
1983 const int32_t *levels = nullptr;
1984 uint32_t levelNum = 0;
1985 ret = OH_AVCapability_GetSupportedLevelsForProfile(nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
1986 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1987 }
1988
1989 /**
1990 * @tc.number : VIDEO_ENCODE_CAPABILITY_7700
1991 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1992 * @tc.desc : api test
1993 */
1994 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7700, TestSize.Level2)
1995 {
1996 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1997 if (cap) {
1998 OH_AVErrCode ret = AV_ERR_OK;
1999 const int32_t *levels = nullptr;
2000 uint32_t levelNum = 0;
2001 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2002 ASSERT_NE(nullptr, capability);
2003 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
2004 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2005 } else {
2006 return;
2007 }
2008 }
2009
2010 /**
2011 * @tc.number : VIDEO_ENCODE_CAPABILITY_7800
2012 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2013 * @tc.desc : api test
2014 */
2015 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7800, TestSize.Level2)
2016 {
2017 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2018 if (cap) {
2019 OH_AVErrCode ret = AV_ERR_OK;
2020 uint32_t levelNum = 0;
2021 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2022 ASSERT_NE(nullptr, capability);
2023 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
2024 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2025 } else {
2026 return;
2027 }
2028 }
2029
2030 /**
2031 * @tc.number : VIDEO_ENCODE_CAPABILITY_7900
2032 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2033 * @tc.desc : api test
2034 */
2035 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7900, TestSize.Level2)
2036 {
2037 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2038 if (cap) {
2039 OH_AVErrCode ret = AV_ERR_OK;
2040 const int32_t *levels = nullptr;
2041 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2042 ASSERT_NE(nullptr, capability);
2043 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, nullptr);
2044 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2045 } else {
2046 return;
2047 }
2048 }
2049
2050 /**
2051 * @tc.number : VIDEO_ENCODE_CAPABILITY_8000
2052 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2053 * @tc.desc : api test
2054 */
2055 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8000, TestSize.Level2)
2056 {
2057 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2058 if (cap) {
2059 OH_AVErrCode ret = AV_ERR_OK;
2060 const int32_t *levels = nullptr;
2061 uint32_t levelNum = 0;
2062 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2063 ASSERT_NE(nullptr, capability);
2064 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, &levelNum);
2065 ASSERT_EQ(AV_ERR_OK, ret);
2066 ASSERT_NE(nullptr, levels);
2067 ASSERT_GT(levelNum, 0);
2068 for (int i = 0; i < levelNum; i++) {
2069 ASSERT_GE(levels[i], 0);
2070 }
2071 } else {
2072 return;
2073 }
2074 }
2075
2076 /**
2077 * @tc.number : VIDEO_ENCODE_CAPABILITY_8100
2078 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2079 * @tc.desc : api test
2080 */
2081 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8100, TestSize.Level2)
2082 {
2083 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(nullptr, AVC_PROFILE_BASELINE, 1));
2084 }
2085
2086 /**
2087 * @tc.number : VIDEO_ENCODE_CAPABILITY_8200
2088 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2089 * @tc.desc : api test
2090 */
2091 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8200, TestSize.Level2)
2092 {
2093 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2094 if (cap) {
2095 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2096 ASSERT_NE(nullptr, capability);
2097 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
2098 } else {
2099 return;
2100 }
2101 }
2102
2103 /**
2104 * @tc.number : VIDEO_ENCODE_CAPABILITY_8300
2105 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2106 * @tc.desc : api test
2107 */
2108 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8300, TestSize.Level2)
2109 {
2110 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2111 if (cap) {
2112 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2113 ASSERT_NE(nullptr, capability);
2114 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
2115 } else {
2116 return;
2117 }
2118 }
2119
2120 /**
2121 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0100
2122 * @tc.name : OH_AVCodec_GetCapability
2123 * @tc.desc : api test
2124 */
2125 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0100, TestSize.Level2)
2126 {
2127 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2128 if (cap) {
2129 ASSERT_NE(nullptr, OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true));
2130 } else {
2131 return;
2132 }
2133 }
2134
2135 /**
2136 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0200
2137 * @tc.name : OH_AVCodec_GetCapabilityByCategory param correct
2138 * @tc.desc : api test
2139 */
2140 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0200, TestSize.Level2)
2141 {
2142 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2143 if (cap) {
2144 ASSERT_NE(nullptr, OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE));
2145 } else {
2146 return;
2147 }
2148 }
2149
2150 /**
2151 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0300
2152 * @tc.name : OH_AVCapability_IsHardware param correct
2153 * @tc.desc : api test
2154 */
2155 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0300, TestSize.Level2)
2156 {
2157 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2158 if (cap) {
2159 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2160 ASSERT_NE(nullptr, capability);
2161 ASSERT_EQ(true, OH_AVCapability_IsHardware(capability));
2162 } else {
2163 return;
2164 }
2165 }
2166
2167 /**
2168 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0400
2169 * @tc.name : OH_AVCapability_GetName param correct
2170 * @tc.desc : api test
2171 */
2172 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0400, TestSize.Level2)
2173 {
2174 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2175 if (cap) {
2176 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2177 ASSERT_NE(nullptr, capability);
2178 const char *name = OH_AVCapability_GetName(capability);
2179 ASSERT_NE(name, nullptr);
2180 ASSERT_GT(strlen(name), 0);
2181 } else {
2182 return;
2183 }
2184 }
2185
2186 /**
2187 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0500
2188 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
2189 * @tc.desc : api test
2190 */
2191
2192 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0500, TestSize.Level2)
2193 {
2194 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2195 if (cap) {
2196 OH_AVErrCode ret = AV_ERR_OK;
2197
2198 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2199 ASSERT_NE(nullptr, capability);
2200
2201 ret = OH_AVCapability_GetEncoderBitrateRange(capability, nullptr);
2202 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2203 } else {
2204 return;
2205 }
2206 }
2207
2208 /**
2209 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0600
2210 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param correct
2211 * @tc.desc : api test
2212 */
2213 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0600, TestSize.Level2)
2214 {
2215 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2216 if (cap) {
2217 OH_AVErrCode ret = AV_ERR_OK;
2218 OH_AVRange range;
2219 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2220 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2221 ASSERT_NE(nullptr, capability);
2222 ret = OH_AVCapability_GetEncoderBitrateRange(capability, &range);
2223 ASSERT_EQ(AV_ERR_OK, ret);
2224 cout << "max val " << range.maxVal << " min val " << range.minVal << endl;
2225 ASSERT_GE(range.minVal, 0);
2226 ASSERT_GT(range.maxVal, 0);
2227 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2228 ASSERT_NE(nullptr, venc_);
2229 format = OH_AVFormat_Create();
2230 ASSERT_NE(nullptr, format);
2231 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2232 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2233 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2234 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, range.minVal - 1);
2235 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
2236 OH_VideoEncoder_Destroy(venc_);
2237 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2238 ASSERT_NE(nullptr, venc_);
2239 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, range.maxVal + 1);
2240 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
2241 } else {
2242 return;
2243 }
2244 }
2245
2246 /**
2247 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_07
2248 * 00
2249 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2250 * @tc.desc : api test
2251 */
2252 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0700, TestSize.Level2)
2253 {
2254 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2255 if (cap) {
2256 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2257 ASSERT_NE(nullptr, capability);
2258 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2259 ASSERT_NE(nullptr, venc_);
2260 format = OH_AVFormat_Create();
2261 ASSERT_NE(nullptr, format);
2262 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2263 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2264 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2265 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2266 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
2267
2268 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_CBR);
2269 EXPECT_EQ(isSupported, true);
2270 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CBR);
2271 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2272 OH_VideoEncoder_Destroy(venc_);
2273 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2274 ASSERT_NE(nullptr, venc_);
2275 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_VBR);
2276 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2277 } else {
2278 return;
2279 }
2280 }
2281
2282 /**
2283 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5200
2284 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2285 * @tc.desc : api test
2286 */
2287 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5200, TestSize.Level2)
2288 {
2289 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2290 if (cap) {
2291 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2292 ASSERT_NE(nullptr, capability);
2293 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2294 ASSERT_NE(nullptr, venc_);
2295 format = OH_AVFormat_Create();
2296 ASSERT_NE(nullptr, format);
2297 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2298 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2299 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2300 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2301 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
2302 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_VBR);
2303 EXPECT_EQ(isSupported, true);
2304 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_VBR);
2305 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2306 } else {
2307 return;
2308 }
2309 }
2310
2311 /**
2312 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5300
2313 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2314 * @tc.desc : api test
2315 */
2316 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5300, TestSize.Level2)
2317 {
2318 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2319 if (cap) {
2320 OH_AVCapability *capa = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2321 ASSERT_NE(nullptr, capa);
2322 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
2323 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2324 ASSERT_NE(nullptr, venc_);
2325 format = OH_AVFormat_Create();
2326 ASSERT_NE(nullptr, format);
2327 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2328 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2329 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2330 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2331 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, DEFAULT_QUALITY);
2332 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
2333 EXPECT_EQ(isSupported, true);
2334 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CQ);
2335 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2336 } else {
2337 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
2338 EXPECT_EQ(isSupported, false);
2339 }
2340 } else {
2341 return;
2342 }
2343 }
2344
2345 /**
2346 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5400
2347 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2348 * @tc.desc : api test
2349 */
2350 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5400, TestSize.Level2)
2351 {
2352 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2353 if (cap) {
2354 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2355 ASSERT_NE(nullptr, capability);
2356 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2357 ASSERT_NE(nullptr, venc_);
2358 format = OH_AVFormat_Create();
2359 ASSERT_NE(nullptr, format);
2360 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2361 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2362 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2363 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2364 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
2365 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, NO_SUPPORT_MODE);
2366 EXPECT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
2367 } else {
2368 return;
2369 }
2370 }
2371
2372 /**
2373 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0800
2374 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
2375 * @tc.desc : api test
2376 */
2377 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0800, TestSize.Level2)
2378 {
2379 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2380 if (cap) {
2381 OH_AVErrCode ret = AV_ERR_OK;
2382 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2383 ASSERT_NE(nullptr, capability);
2384 ret = OH_AVCapability_GetEncoderQualityRange(capability, nullptr);
2385 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2386 } else {
2387 return;
2388 }
2389 }
2390
2391 /**
2392 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0900
2393 * @tc.name : OH_AVCapability_GetEncoderQualityRange param correct
2394 * @tc.desc : api test
2395 */
2396 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0900, TestSize.Level2)
2397 {
2398 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2399 if (cap) {
2400 OH_AVErrCode ret = AV_ERR_OK;
2401 OH_AVRange range;
2402 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2403 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2404 ASSERT_NE(nullptr, capability);
2405 ret = OH_AVCapability_GetEncoderQualityRange(capability, &range);
2406 ASSERT_EQ(AV_ERR_OK, ret);
2407 ASSERT_EQ(range.minVal, 0);
2408 ASSERT_EQ(range.maxVal, MAX_QUALITY);
2409 } else {
2410 return;
2411 }
2412 }
2413
2414 /**
2415 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1000
2416 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
2417 * @tc.desc : api test
2418 */
2419 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1000, TestSize.Level2)
2420 {
2421 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2422 if (cap) {
2423 OH_AVErrCode ret = AV_ERR_OK;
2424 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2425 ASSERT_NE(nullptr, capability);
2426 ret = OH_AVCapability_GetEncoderComplexityRange(capability, nullptr);
2427 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2428 } else {
2429 return;
2430 }
2431 }
2432
2433 /**
2434 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1100
2435 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param correct
2436 * @tc.desc : api test
2437 */
2438 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1100, TestSize.Level2)
2439 {
2440 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2441 if (cap) {
2442 OH_AVErrCode ret = AV_ERR_OK;
2443 OH_AVRange range;
2444 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2445 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2446 ASSERT_NE(nullptr, capability);
2447 ret = OH_AVCapability_GetEncoderComplexityRange(capability, &range);
2448 ASSERT_EQ(AV_ERR_OK, ret);
2449 } else {
2450 return;
2451 }
2452 }
2453
2454 /**
2455 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1200
2456 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
2457 * @tc.desc : api test
2458 */
2459 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1200, TestSize.Level2)
2460 {
2461 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2462 if (cap) {
2463 OH_AVErrCode ret = AV_ERR_OK;
2464 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2465 ASSERT_NE(nullptr, capability);
2466 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
2467 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2468 } else {
2469 return;
2470 }
2471 }
2472
2473 /**
2474 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1300
2475 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
2476 * @tc.desc : api test
2477 */
2478 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1300, TestSize.Level2)
2479 {
2480 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2481 if (cap) {
2482 OH_AVErrCode ret = AV_ERR_OK;
2483 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2484 ASSERT_NE(nullptr, capability);
2485 int32_t alignment = 0;
2486 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
2487 ASSERT_EQ(AV_ERR_OK, ret);
2488 ASSERT_GE(alignment, 0);
2489 } else {
2490 return;
2491 }
2492 }
2493
2494 /**
2495 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1400
2496 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
2497 * @tc.desc : api test
2498 */
2499 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1400, TestSize.Level2)
2500 {
2501 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2502 if (cap) {
2503 OH_AVErrCode ret = AV_ERR_OK;
2504 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2505 ASSERT_NE(nullptr, capability);
2506 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
2507 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2508 } else {
2509 return;
2510 }
2511 }
2512
2513 /**
2514 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1500
2515 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
2516 * @tc.desc : api test
2517 */
2518 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1500, TestSize.Level2)
2519 {
2520 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2521 if (cap) {
2522 OH_AVErrCode ret = AV_ERR_OK;
2523 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2524 ASSERT_NE(nullptr, capability);
2525 int32_t alignment = 0;
2526 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
2527 ASSERT_EQ(AV_ERR_OK, ret);
2528 ASSERT_GE(alignment, 0);
2529 } else {
2530 return;
2531 }
2532 }
2533
2534 /**
2535 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1600
2536 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
2537 * @tc.desc : api test
2538 */
2539 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1600, TestSize.Level2)
2540 {
2541 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2542 if (cap) {
2543 OH_AVErrCode ret = AV_ERR_OK;
2544 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2545 ASSERT_NE(nullptr, capability);
2546 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_WIDTH, nullptr);
2547 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2548 } else {
2549 return;
2550 }
2551 }
2552
2553 /**
2554 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1700
2555 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
2556 * @tc.desc : api test
2557 */
2558 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1700, TestSize.Level2)
2559 {
2560 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2561 if (cap) {
2562 OH_AVErrCode ret = AV_ERR_OK;
2563 OH_AVRange range;
2564 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2565 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2566 ASSERT_NE(nullptr, capability);
2567 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
2568 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2569 } else {
2570 return;
2571 }
2572 }
2573
2574 /**
2575 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1900
2576 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
2577 * @tc.desc : api test
2578 */
2579 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1900, TestSize.Level2)
2580 {
2581 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2582 if (cap) {
2583 OH_AVErrCode ret = AV_ERR_OK;
2584 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2585 ASSERT_NE(nullptr, capability);
2586 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_HEIGHT, nullptr);
2587 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2588 } else {
2589 return;
2590 }
2591 }
2592
2593 /**
2594 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2000
2595 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
2596 * @tc.desc : api test
2597 */
2598 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2000, TestSize.Level2)
2599 {
2600 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2601 if (cap) {
2602 OH_AVErrCode ret = AV_ERR_OK;
2603 OH_AVRange range;
2604 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2605 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2606 ASSERT_NE(nullptr, capability);
2607 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
2608 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2609 } else {
2610 return;
2611 }
2612 }
2613
2614 /**
2615 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2100
2616 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
2617 * @tc.desc : api test
2618 */
2619 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2100, TestSize.Level2)
2620 {
2621 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2622 if (cap) {
2623 OH_AVErrCode ret = AV_ERR_OK;
2624 OH_AVRange range;
2625 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2626 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2627 ASSERT_NE(nullptr, capability);
2628 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
2629 ASSERT_EQ(AV_ERR_OK, ret);
2630 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2631 ASSERT_GE(range.minVal, 0);
2632 ASSERT_GT(range.maxVal, 0);
2633 } else {
2634 return;
2635 }
2636 }
2637
2638 /**
2639 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2200
2640 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
2641 * @tc.desc : api test
2642 */
2643 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2200, TestSize.Level2)
2644 {
2645 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2646 if (cap) {
2647 OH_AVErrCode ret = AV_ERR_OK;
2648 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2649 ASSERT_NE(nullptr, capability);
2650 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
2651 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2652 } else {
2653 return;
2654 }
2655 }
2656
2657 /**
2658 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2300
2659 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
2660 * @tc.desc : api test
2661 */
2662 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2300, TestSize.Level2)
2663 {
2664 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2665 if (cap) {
2666 OH_AVErrCode ret = AV_ERR_OK;
2667 OH_AVRange range;
2668 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2669 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2670 ASSERT_NE(nullptr, capability);
2671 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
2672 ASSERT_EQ(AV_ERR_OK, ret);
2673 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2674 ASSERT_GE(range.minVal, 0);
2675 ASSERT_GT(range.maxVal, 0);
2676 } else {
2677 return;
2678 }
2679 }
2680
2681 /**
2682 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2400
2683 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
2684 * @tc.desc : api test
2685 */
2686 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2400, TestSize.Level2)
2687 {
2688 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2689 if (cap) {
2690 OH_AVErrCode ret = AV_ERR_OK;
2691 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2692 ASSERT_NE(nullptr, capability);
2693 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
2694 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2695 } else {
2696 return;
2697 }
2698 }
2699
2700 /**
2701 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2500
2702 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
2703 * @tc.desc : api test
2704 */
2705 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2500, TestSize.Level2)
2706 {
2707 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2708 if (cap) {
2709 OH_AVErrCode ret = AV_ERR_OK;
2710 OH_AVRange range;
2711 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2712 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2713 ASSERT_NE(nullptr, capability);
2714 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
2715 ASSERT_EQ(AV_ERR_OK, ret);
2716 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2717 ASSERT_GE(range.minVal, 0);
2718 ASSERT_GT(range.maxVal, 0);
2719 } else {
2720 return;
2721 }
2722 }
2723
2724 /**
2725 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2600
2726 * @tc.name : configure encoder with illegal width and height
2727 * @tc.desc : api test
2728 */
2729 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2600, TestSize.Level2)
2730 {
2731 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2732 if (cap) {
2733 OH_AVErrCode ret = AV_ERR_OK;
2734 OH_AVRange widthRange;
2735 OH_AVRange heightRange;
2736 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2737 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2738 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2739 ASSERT_NE(nullptr, capability);
2740 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
2741 ASSERT_EQ(AV_ERR_OK, ret);
2742 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
2743 ASSERT_EQ(AV_ERR_OK, ret);
2744 ASSERT_GE(heightRange.minVal, 0);
2745 ASSERT_GT(heightRange.maxVal, 0);
2746 ASSERT_GE(widthRange.minVal, 0);
2747 ASSERT_GT(widthRange.maxVal, 0);
2748 } else {
2749 return;
2750 }
2751 }
2752
2753 /**
2754 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2700
2755 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
2756 * @tc.desc : api test
2757 */
2758 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2700, TestSize.Level2)
2759 {
2760 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2761 if (cap) {
2762 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2763 ASSERT_NE(nullptr, capability);
2764 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
2765 } else {
2766 return;
2767 }
2768 }
2769
2770 /**
2771 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2800
2772 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
2773 * @tc.desc : api test
2774 */
2775 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2800, TestSize.Level2)
2776 {
2777 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2778 if (cap) {
2779 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2780 ASSERT_NE(nullptr, capability);
2781 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
2782 } else {
2783 return;
2784 }
2785 }
2786
2787 /**
2788 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2900
2789 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
2790 * @tc.desc : api test
2791 */
2792 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2900, TestSize.Level2)
2793 {
2794 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2795 if (cap) {
2796 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2797 ASSERT_NE(nullptr, capability);
2798 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
2799 } else {
2800 return;
2801 }
2802 }
2803
2804 /**
2805 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3000
2806 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
2807 * @tc.desc : api test
2808 */
2809 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3000, TestSize.Level2)
2810 {
2811 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2812 if (cap) {
2813 OH_AVErrCode ret = AV_ERR_OK;
2814 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2815 ASSERT_NE(nullptr, capability);
2816 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
2817 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2818 } else {
2819 return;
2820 }
2821 }
2822 } // namespace
2823