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