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