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