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 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
99 if (cap) {
100 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
101 ASSERT_NE(nullptr, venc_);
102 } else {
103 return;
104 }
105 }
106
107 /**
108 * @tc.number : VIDEO_ENCODE_FUNCTION_0200
109 * @tc.name : create by name
110 * @tc.desc : function test
111 */
112 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0200, TestSize.Level1)
113 {
114 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
115 if (cap) {
116 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
117 ASSERT_NE(nullptr, venc_);
118 } else {
119 return;
120 }
121 }
122
123 /**
124 * @tc.number : VIDEO_ENCODE_FUNCTION_0300
125 * @tc.name : create no exist encoder
126 * @tc.desc : function test
127 */
128 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0300, TestSize.Level1)
129 {
130 venc_ = OH_VideoEncoder_CreateByName("aabbccdd");
131 ASSERT_EQ(nullptr, venc_);
132 }
133
134 /**
135 * @tc.number : VIDEO_ENCODE_FUNCTION_0400
136 * @tc.name : test encode buffer
137 * @tc.desc : function test
138 */
139 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0400, TestSize.Level1)
140 {
141 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
142 if (cap) {
143 auto vEncSample = make_unique<VEncNdkSample>();
144 vEncSample->INP_DIR = INP_DIR_720;
145 vEncSample->DEFAULT_WIDTH = 1280;
146 vEncSample->DEFAULT_HEIGHT = 720;
147 vEncSample->DEFAULT_FRAME_RATE = 30;
148 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
149 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
150 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
151 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
152 vEncSample->WaitForEOS();
153 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
154 } else {
155 return;
156 }
157 }
158
159 /**
160 * @tc.number : VIDEO_ENCODE_FUNCTION_0500
161 * @tc.name : test encode surface
162 * @tc.desc : function test
163 */
164 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0500, TestSize.Level1)
165 {
166 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
167 if (cap) {
168 auto vEncSample = make_unique<VEncNdkSample>();
169 vEncSample->INP_DIR = INP_DIR_720;
170 vEncSample->DEFAULT_WIDTH = 1280;
171 vEncSample->DEFAULT_HEIGHT = 720;
172 vEncSample->DEFAULT_FRAME_RATE = 30;
173 vEncSample->SURF_INPUT = true;
174 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
175 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
176 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
177 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
178 vEncSample->WaitForEOS();
179 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
180 } else {
181 return;
182 }
183 }
184
185 /**
186 * @tc.number : VIDEO_ENCODE_FUNCTION_0600
187 * @tc.name : set force IDR when encoding
188 * @tc.desc : function test
189 */
190 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0600, TestSize.Level1)
191 {
192 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
193 if (cap) {
194 auto vEncSample = make_unique<VEncNdkSample>();
195 vEncSample->INP_DIR = INP_DIR_720;
196 vEncSample->DEFAULT_WIDTH = 1280;
197 vEncSample->DEFAULT_HEIGHT = 720;
198 vEncSample->DEFAULT_FRAME_RATE = 30;
199 vEncSample->enableForceIDR = true;
200 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
201 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
202 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
203 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
204 vEncSample->WaitForEOS();
205 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
206 } else {
207 return;
208 }
209 }
210
211 /**
212 * @tc.number : VIDEO_ENCODE_FUNCTION_0700
213 * @tc.name : set color format
214 * @tc.desc : function test
215 */
216 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0700, TestSize.Level1)
217 {
218 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
219 if (cap) {
220 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
221 ASSERT_NE(nullptr, venc_);
222 format = OH_AVFormat_Create();
223 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_RANGE_FLAG, 1));
224 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_COLOR_PRIMARIES, OH_ColorPrimary::COLOR_PRIMARY_BT709));
225 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_TRANSFER_CHARACTERISTICS,
226 OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_LINEAR));
227 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_MATRIX_COEFFICIENTS,
228 OH_MatrixCoefficient::MATRIX_COEFFICIENT_YCGCO));
229 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
230 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
231 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
232 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
233 } else {
234 return;
235 }
236 }
237
238 /**
239 * @tc.number : VIDEO_ENCODE_FUNCTION_0800
240 * @tc.name : set key frame interval avc
241 * @tc.desc : function test
242 */
243 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0800, TestSize.Level1)
244 {
245 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
246 if (cap) {
247 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
248 ASSERT_NE(nullptr, venc_);
249 format = OH_AVFormat_Create();
250 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, SECOND));
251 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
252 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
253 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
254 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
255 OH_VideoEncoder_Destroy(venc_);
256 OH_AVFormat_Destroy(format);
257
258 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
259 ASSERT_NE(nullptr, venc_);
260 format = OH_AVFormat_Create();
261 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, -1));
262 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
263 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
264 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
265 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
266 OH_VideoEncoder_Destroy(venc_);
267 OH_AVFormat_Destroy(format);
268
269 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
270 ASSERT_NE(nullptr, venc_);
271 format = OH_AVFormat_Create();
272 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, 0));
273 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
274 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
275 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
276 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
277 OH_VideoEncoder_Destroy(venc_);
278 OH_AVFormat_Destroy(format);
279
280 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
281 ASSERT_NE(nullptr, venc_);
282 format = OH_AVFormat_Create();
283 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, INT_MAX));
284 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
285 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
286 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
287 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
288 } else {
289 return;
290 }
291 }
292
293 /**
294 * @tc.number : VIDEO_ENCODE_FUNCTION_0810
295 * @tc.name : set key frame interval hevc
296 * @tc.desc : function test
297 */
298 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0810, TestSize.Level1)
299 {
300 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
301 if (cap) {
302 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
303 ASSERT_NE(nullptr, venc_);
304 format = OH_AVFormat_Create();
305 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, SECOND));
306 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
307 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
308 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
309 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
310 OH_VideoEncoder_Destroy(venc_);
311 OH_AVFormat_Destroy(format);
312
313 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
314 ASSERT_NE(nullptr, venc_);
315 format = OH_AVFormat_Create();
316 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, -1));
317 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
318 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
319 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
320 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
321 OH_VideoEncoder_Destroy(venc_);
322 OH_AVFormat_Destroy(format);
323
324 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
325 ASSERT_NE(nullptr, venc_);
326 format = OH_AVFormat_Create();
327 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, 0));
328 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
329 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
330 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
331 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
332 OH_VideoEncoder_Destroy(venc_);
333 OH_AVFormat_Destroy(format);
334
335 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
336 ASSERT_NE(nullptr, venc_);
337 format = OH_AVFormat_Create();
338 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, INT_MAX));
339 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
340 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
341 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
342 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
343 } else {
344 return;
345 }
346 }
347
348 /**
349 * @tc.number : VIDEO_ENCODE_FUNCTION_0900
350 * @tc.name : set profile level
351 * @tc.desc : function test
352 */
353 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0900, TestSize.Level1)
354 {
355 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
356 if (cap) {
357 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
358 ASSERT_NE(nullptr, venc_);
359 format = OH_AVFormat_Create();
360 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_BASELINE);
361 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
362 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
363 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
364 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
365 OH_AVFormat_Destroy(format);
366 OH_VideoEncoder_Destroy(venc_);
367
368 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
369 ASSERT_NE(nullptr, venc_);
370 format = OH_AVFormat_Create();
371 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_HIGH);
372 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
373 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
374 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
375 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
376 OH_AVFormat_Destroy(format);
377 OH_VideoEncoder_Destroy(venc_);
378
379 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
380 ASSERT_NE(nullptr, venc_);
381 format = OH_AVFormat_Create();
382 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN);
383 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
384 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
385 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
386 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
387 OH_AVFormat_Destroy(format);
388 OH_VideoEncoder_Destroy(venc_);
389
390 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
391 ASSERT_NE(nullptr, venc_);
392 format = OH_AVFormat_Create();
393 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN + AVC_PROFILE_MAIN);
394 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
395 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
396 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
397 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
398 } else {
399 return;
400 }
401 }
402
403 /**
404 * @tc.number : VIDEO_ENCODE_FUNCTION_1000
405 * @tc.name : set bitrate mode
406 * @tc.desc : function test
407 */
408 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1000, TestSize.Level1)
409 {
410 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
411 if (cap) {
412 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
413 ASSERT_NE(nullptr, venc_);
414 format = OH_AVFormat_Create();
415
416 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR));
417 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
418 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
419 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
420 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
421 } else {
422 return;
423 }
424 }
425
426 /**
427 * @tc.number : VIDEO_ENCODE_FUNCTION_1100
428 * @tc.name : set bitrate value
429 * @tc.desc : function test
430 */
431 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1100, TestSize.Level1)
432 {
433 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
434 if (cap) {
435 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
436 ASSERT_NE(nullptr, venc_);
437 format = OH_AVFormat_Create();
438 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR));
439 ASSERT_EQ(true, OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 1000000));
440 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
441 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
442 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
443 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
444 } else {
445 return;
446 }
447 }
448
449 /**
450 * @tc.number : VIDEO_ENCODE_FUNCTION_1400
451 * @tc.name : set framerate
452 * @tc.desc : function test
453 */
454 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1400, TestSize.Level1)
455 {
456 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
457 if (cap) {
458 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
459 ASSERT_NE(nullptr, venc_);
460 format = OH_AVFormat_Create();
461
462 ASSERT_EQ(true, OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, 60));
463 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
464 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
465 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
466 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
467 } else {
468 return;
469 }
470 }
471
472 /**
473 * @tc.number : VIDEO_ENCODE_FUNCTION_1600
474 * @tc.name : set quality
475 * @tc.desc : function test
476 */
477 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1600, TestSize.Level1)
478 {
479 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
480 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
481 ASSERT_NE(nullptr, venc_);
482 format = OH_AVFormat_Create();
483 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CQ));
484 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, 60));
485 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
486 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
487 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
488 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
489 }
490 }
491
492 /**
493 * @tc.number : VIDEO_ENCODE_FUNCTION_1700
494 * @tc.name : input frame after EOS
495 * @tc.desc : function test
496 */
497 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1700, TestSize.Level1)
498 {
499 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
500 if (cap) {
501 auto vEncSample = make_unique<VEncNdkSample>();
502 vEncSample->INP_DIR = INP_DIR_720;
503 vEncSample->DEFAULT_WIDTH = 1280;
504 vEncSample->DEFAULT_HEIGHT = 720;
505 vEncSample->DEFAULT_FRAME_RATE = 30;
506 vEncSample->enable_random_eos = true;
507 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
508 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
509 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
510 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
511 vEncSample->WaitForEOS();
512 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
513 } else {
514 return;
515 }
516 }
517
518 /**
519 * @tc.number : VIDEO_ENCODE_FUNCTION_1800
520 * @tc.name : encode h265 buffer
521 * @tc.desc : function test
522 */
523 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1800, TestSize.Level1)
524 {
525 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
526 if (cap) {
527 auto vEncSample = make_unique<VEncNdkSample>();
528 vEncSample->INP_DIR = INP_DIR_720;
529 vEncSample->DEFAULT_WIDTH = 1280;
530 vEncSample->DEFAULT_HEIGHT = 720;
531 vEncSample->DEFAULT_FRAME_RATE = 30;
532 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
533 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
534 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
535 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
536 vEncSample->WaitForEOS();
537 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
538 } else {
539 return;
540 }
541 }
542
543 /**
544 * @tc.number : VIDEO_ENCODE_FUNCTION_2000
545 * @tc.name : encode RGBA h265 buffer mode
546 * @tc.desc : function test
547 */
548 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_2000, TestSize.Level1)
549 {
550 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
551 if (cap) {
552 auto vEncSample = make_unique<VEncNdkSample>();
553 vEncSample->INP_DIR = "/data/test/media/test.rgba";
554 vEncSample->DEFAULT_WIDTH = 1280;
555 vEncSample->DEFAULT_HEIGHT = 720;
556 vEncSample->DEFAULT_FRAME_RATE = 30;
557 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA;
558 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
559 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
560 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
561 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
562 vEncSample->WaitForEOS();
563 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
564 } else {
565 return;
566 }
567 }
568
569 /**
570 * @tc.number : VIDEO_ENCODE_FUNCTION_1900
571 * @tc.name : encode h265 surface
572 * @tc.desc : function test
573 */
574 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1900, TestSize.Level1)
575 {
576 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
577 if (cap) {
578 auto vEncSample = make_unique<VEncNdkSample>();
579 vEncSample->INP_DIR = INP_DIR_720;
580 vEncSample->DEFAULT_WIDTH = 1280;
581 vEncSample->DEFAULT_HEIGHT = 720;
582 vEncSample->DEFAULT_FRAME_RATE = 30;
583 vEncSample->SURF_INPUT = true;
584 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
585 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
586 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
587 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
588 vEncSample->WaitForEOS();
589 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
590 } else {
591 return;
592 }
593 }
594
595 /**
596 * @tc.number : VIDEO_ENCODE_CAPABILITY_0100
597 * @tc.name : OH_AVCodec_GetCapability para error
598 * @tc.desc : api test
599 */
600 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0100, TestSize.Level2)
601 {
602 const char *p = nullptr;
603 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability(p, true));
604 }
605
606 /**
607 * @tc.number : VIDEO_ENCODE_CAPABILITY_0200
608 * @tc.name : OH_AVCodec_GetCapability para error
609 * @tc.desc : api test
610 */
611 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0200, TestSize.Level2)
612 {
613 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability("", true));
614 }
615
616 /**
617 * @tc.number : VIDEO_ENCODE_CAPABILITY_0300
618 * @tc.name : OH_AVCodec_GetCapability para error
619 * @tc.desc : api test
620 */
621 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0300, TestSize.Level2)
622 {
623 ASSERT_EQ(nullptr, OH_AVCodec_GetCapability("notexist", true));
624 }
625
626 /**
627 * @tc.number : VIDEO_ENCODE_CAPABILITY_0400
628 * @tc.name : OH_AVCodec_GetCapability
629 * @tc.desc : api test
630 */
631 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0400, TestSize.Level2)
632 {
633 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
634 if (cap) {
635 ASSERT_NE(nullptr, OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true));
636 } else {
637 return;
638 }
639 }
640
641 /**
642 * @tc.number : VIDEO_ENCODE_CAPABILITY_0500
643 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
644 * @tc.desc : api test
645 */
646 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0500, TestSize.Level2)
647 {
648 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory("", true, HARDWARE));
649 }
650 /**
651 * @tc.number : VIDEO_ENCODE_CAPABILITY_9900
652 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
653 * @tc.desc : api test
654 */
655 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_9900, TestSize.Level2)
656 {
657 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory(nullptr, true, HARDWARE));
658 }
659
660 /**
661 * @tc.number : VIDEO_ENCODE_CAPABILITY_0600
662 * @tc.name : OH_AVCodec_GetCapabilityByCategory para error
663 * @tc.desc : api test
664 */
665 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0600, TestSize.Level2)
666 {
667 ASSERT_EQ(nullptr, OH_AVCodec_GetCapabilityByCategory("notexist", true, HARDWARE));
668 }
669
670 /**
671 * @tc.number : VIDEO_ENCODE_CAPABILITY_0700
672 * @tc.name : OH_AVCodec_GetCapabilityByCategory param correct
673 * @tc.desc : api test
674 */
675 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0700, TestSize.Level2)
676 {
677 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
678 if (cap) {
679 ASSERT_NE(nullptr, OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE));
680 } else {
681 return;
682 }
683 }
684
685 /**
686 * @tc.number : VIDEO_ENCODE_CAPABILITY_0800
687 * @tc.name : OH_AVCapability_IsHardware param error
688 * @tc.desc : api test
689 */
690 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0800, TestSize.Level2)
691 {
692 ASSERT_EQ(false, OH_AVCapability_IsHardware(nullptr));
693 }
694
695 /**
696 * @tc.number : VIDEO_ENCODE_CAPABILITY_0900
697 * @tc.name : OH_AVCapability_IsHardware param correct
698 * @tc.desc : api test
699 */
700 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_0900, TestSize.Level2)
701 {
702 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
703 if (cap) {
704 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
705 ASSERT_NE(nullptr, capability);
706 ASSERT_EQ(true, OH_AVCapability_IsHardware(capability));
707 } else {
708 return;
709 }
710 }
711
712 /**
713 * @tc.number : VIDEO_ENCODE_CAPABILITY_1000
714 * @tc.name : OH_AVCapability_GetName param error
715 * @tc.desc : api test
716 */
717 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1000, TestSize.Level2)
718 {
719 const char *name = OH_AVCapability_GetName(nullptr);
720 ASSERT_NE(name, nullptr);
721 ASSERT_EQ(strlen(name), 0);
722 }
723
724 /**
725 * @tc.number : VIDEO_ENCODE_CAPABILITY_1100
726 * @tc.name : OH_AVCapability_GetName param correct
727 * @tc.desc : api test
728 */
729 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1100, TestSize.Level2)
730 {
731 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
732 if (cap) {
733 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
734 ASSERT_NE(nullptr, capability);
735 const char *name = OH_AVCapability_GetName(capability);
736 ASSERT_NE(name, nullptr);
737 ASSERT_GT(strlen(name), 0);
738 } else {
739 return;
740 }
741 }
742
743 /**
744 * @tc.number : VIDEO_ENCODE_CAPABILITY_1200
745 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param error
746 * @tc.desc : api test
747 */
748 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1200, TestSize.Level2)
749 {
750 int32_t maxSupportedInstance = OH_AVCapability_GetMaxSupportedInstances(nullptr);
751 ASSERT_EQ(maxSupportedInstance, 0);
752 }
753
754 /**
755 * @tc.number : VIDEO_ENCODE_CAPABILITY_1300
756 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param correct
757 * @tc.desc : api test
758 */
759 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1300, TestSize.Level2)
760 {
761 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
762 if (cap) {
763 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
764 ASSERT_NE(nullptr, capability);
765
766 string codecName = OH_AVCapability_GetName(capability);
767 if (codecName == "OMX.hisi.video.encoder.avc") {
768 ASSERT_EQ(16, OH_AVCapability_GetMaxSupportedInstances(capability));
769 } else {
770 ASSERT_EQ(4, OH_AVCapability_GetMaxSupportedInstances(capability));
771 }
772 } else {
773 return;
774 }
775 }
776
777 /**
778 * @tc.number : VIDEO_ENCODE_CAPABILITY_1310
779 * @tc.name : OH_AVCapability_GetMaxSupportedInstances param correct
780 * @tc.desc : api test
781 */
782 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1310, TestSize.Level2)
783 {
784 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
785 if (cap) {
786 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
787 ASSERT_NE(nullptr, capability);
788
789 string codecName = OH_AVCapability_GetName(capability);
790 if (codecName == "OMX.hisi.video.encoder.hevc") {
791 ASSERT_EQ(16, OH_AVCapability_GetMaxSupportedInstances(capability));
792 } else {
793 ASSERT_EQ(4, OH_AVCapability_GetMaxSupportedInstances(capability));
794 }
795 } else {
796 return;
797 }
798 }
799
800 /**
801 * @tc.number : VIDEO_ENCODE_CAPABILITY_1400
802 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
803 * @tc.desc : api test
804 */
805 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1400, TestSize.Level2)
806 {
807 OH_AVErrCode ret = AV_ERR_OK;
808 OH_AVRange range;
809 ret = OH_AVCapability_GetEncoderBitrateRange(nullptr, &range);
810 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
811 }
812
813 /**
814 * @tc.number : VIDEO_ENCODE_CAPABILITY_1500
815 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
816 * @tc.desc : api test
817 */
818
819 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1500, TestSize.Level2)
820 {
821 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
822 if (cap) {
823 OH_AVErrCode ret = AV_ERR_OK;
824
825 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
826 ASSERT_NE(nullptr, capability);
827
828 ret = OH_AVCapability_GetEncoderBitrateRange(capability, nullptr);
829 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
830 } else {
831 return;
832 }
833 }
834
835 /**
836 * @tc.number : VIDEO_ENCODE_CAPABILITY_1700
837 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param correct
838 * @tc.desc : api test
839 */
840 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1700, TestSize.Level2)
841 {
842 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
843 if (cap) {
844 OH_AVErrCode ret = AV_ERR_OK;
845 OH_AVRange range;
846 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
847 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
848 ASSERT_NE(nullptr, capability);
849 ret = OH_AVCapability_GetEncoderBitrateRange(capability, &range);
850 ASSERT_EQ(AV_ERR_OK, ret);
851 cout << "max val " << range.maxVal << " min val " << range.minVal << endl;
852 ASSERT_GE(range.minVal, 0);
853 ASSERT_GT(range.maxVal, 0);
854 } else {
855 return;
856 }
857 }
858
859 /**
860 * @tc.number : VIDEO_ENCODE_CAPABILITY_1800
861 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param error
862 * @tc.desc : api test
863 */
864 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1800, TestSize.Level2)
865 {
866 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(nullptr, BITRATE_MODE_CBR);
867 ASSERT_EQ(false, isSupported);
868 }
869
870 /**
871 * @tc.number : VIDEO_ENCODE_CAPABILITY_1900
872 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
873 * @tc.desc : api test
874 */
875 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_1900, TestSize.Level2)
876 {
877 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
878 if (cap) {
879 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
880 ASSERT_NE(nullptr, capability);
881 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
882 ASSERT_NE(nullptr, venc_);
883 format = OH_AVFormat_Create();
884 ASSERT_NE(nullptr, format);
885 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
886 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
887 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
888 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
889 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
890
891 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_CBR);
892 EXPECT_EQ(isSupported, true);
893 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CBR);
894 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
895 } else {
896 return;
897 }
898 }
899
900 /**
901 * @tc.number : VIDEO_ENCODE_CAPABILITY_8400
902 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
903 * @tc.desc : api test
904 */
905 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8400, TestSize.Level2)
906 {
907 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
908 if (cap) {
909 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
910 ASSERT_NE(nullptr, capability);
911 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
912 ASSERT_NE(nullptr, venc_);
913 format = OH_AVFormat_Create();
914 ASSERT_NE(nullptr, format);
915 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
916 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
917 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
918 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
919 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
920
921 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_VBR);
922 EXPECT_EQ(isSupported, true);
923 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_VBR);
924 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
925 } else {
926 return;
927 }
928 }
929
930 /**
931 * @tc.number : VIDEO_ENCODE_CAPABILITY_8500
932 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
933 * @tc.desc : api test
934 */
935 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8500, TestSize.Level2)
936 {
937 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
938 if (cap) {
939 OH_AVCapability *capa = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
940 ASSERT_NE(nullptr, capa);
941 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
942 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
943 ASSERT_NE(nullptr, venc_);
944 format = OH_AVFormat_Create();
945 ASSERT_NE(nullptr, format);
946 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
947 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
948 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
949 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
950 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, DEFAULT_QUALITY);
951 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
952 EXPECT_EQ(isSupported, true);
953 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CQ);
954 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
955 } else {
956 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
957 EXPECT_EQ(isSupported, false);
958 }
959 } else {
960 return;
961 }
962 }
963
964 /**
965 * @tc.number : VIDEO_ENCODE_CAPABILITY_8600
966 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
967 * @tc.desc : api test
968 */
969 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8600, TestSize.Level2)
970 {
971 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
972 if (cap) {
973 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
974 ASSERT_NE(nullptr, capability);
975 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
976 ASSERT_NE(nullptr, venc_);
977 format = OH_AVFormat_Create();
978 ASSERT_NE(nullptr, format);
979 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
980 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
981 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
982 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
983 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
984
985 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CQ + BITRATE_MODE_CQ);
986 EXPECT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
987 } else {
988 return;
989 }
990 }
991
992 /**
993 * @tc.number : VIDEO_ENCODE_CAPABILITY_2000
994 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
995 * @tc.desc : api test
996 */
997 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2000, TestSize.Level2)
998 {
999 OH_AVErrCode ret = AV_ERR_OK;
1000 OH_AVRange range;
1001 ret = OH_AVCapability_GetEncoderQualityRange(nullptr, &range);
1002 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1003 }
1004
1005 /**
1006 * @tc.number : VIDEO_ENCODE_CAPABILITY_2100
1007 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
1008 * @tc.desc : api test
1009 */
1010 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2100, TestSize.Level2)
1011 {
1012 OH_AVErrCode ret = AV_ERR_OK;
1013 ret = OH_AVCapability_GetEncoderQualityRange(nullptr, nullptr);
1014 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1015 }
1016
1017 /**
1018 * @tc.number : VIDEO_ENCODE_CAPABILITY_2200
1019 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
1020 * @tc.desc : api test
1021 */
1022 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2200, TestSize.Level2)
1023 {
1024 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1025 if (cap) {
1026 OH_AVErrCode ret = AV_ERR_OK;
1027 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1028 ASSERT_NE(nullptr, capability);
1029 ret = OH_AVCapability_GetEncoderQualityRange(capability, nullptr);
1030 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1031 } else {
1032 return;
1033 }
1034 }
1035
1036 /**
1037 * @tc.number : VIDEO_ENCODE_CAPABILITY_2300
1038 * @tc.name : OH_AVCapability_GetEncoderQualityRange param correct
1039 * @tc.desc : api test
1040 */
1041 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2300, TestSize.Level2)
1042 {
1043 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1044 if (cap) {
1045 OH_AVErrCode ret = AV_ERR_OK;
1046 OH_AVRange range;
1047 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1048 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1049 ASSERT_NE(nullptr, capability);
1050 ret = OH_AVCapability_GetEncoderQualityRange(capability, &range);
1051 ASSERT_EQ(AV_ERR_OK, ret);
1052 ASSERT_EQ(range.minVal, 0);
1053 ASSERT_EQ(range.maxVal, MAX_QUALITY);
1054 } else {
1055 return;
1056 }
1057 }
1058
1059 /**
1060 * @tc.number : VIDEO_ENCODE_CAPABILITY_2400
1061 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
1062 * @tc.desc : api test
1063 */
1064 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2400, TestSize.Level2)
1065 {
1066 OH_AVErrCode ret = AV_ERR_OK;
1067 ret = OH_AVCapability_GetEncoderComplexityRange(nullptr, nullptr);
1068 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1069 }
1070
1071 /**
1072 * @tc.number : VIDEO_ENCODE_CAPABILITY_2500
1073 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
1074 * @tc.desc : api test
1075 */
1076 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2500, TestSize.Level2)
1077 {
1078 OH_AVErrCode ret = AV_ERR_OK;
1079 OH_AVRange range;
1080 ret = OH_AVCapability_GetEncoderComplexityRange(nullptr, &range);
1081 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1082 }
1083
1084 /**
1085 * @tc.number : VIDEO_ENCODE_CAPABILITY_2700
1086 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
1087 * @tc.desc : api test
1088 */
1089 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2700, TestSize.Level2)
1090 {
1091 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1092 if (cap) {
1093 OH_AVErrCode ret = AV_ERR_OK;
1094 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1095 ASSERT_NE(nullptr, capability);
1096 ret = OH_AVCapability_GetEncoderComplexityRange(capability, nullptr);
1097 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1098 } else {
1099 return;
1100 }
1101 }
1102
1103 /**
1104 * @tc.number : VIDEO_ENCODE_CAPABILITY_2800
1105 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param correct
1106 * @tc.desc : api test
1107 */
1108 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_2800, TestSize.Level2)
1109 {
1110 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1111 if (cap) {
1112 OH_AVErrCode ret = AV_ERR_OK;
1113 OH_AVRange range;
1114 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1115 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1116 ASSERT_NE(nullptr, capability);
1117 ret = OH_AVCapability_GetEncoderComplexityRange(capability, &range);
1118 ASSERT_EQ(AV_ERR_OK, ret);
1119 } else {
1120 return;
1121 }
1122 }
1123
1124 /**
1125 * @tc.number : VIDEO_ENCODE_CAPABILITY_3100
1126 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
1127 * @tc.desc : api test
1128 */
1129 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3100, TestSize.Level2)
1130 {
1131 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1132 if (cap) {
1133 OH_AVErrCode ret = AV_ERR_OK;
1134 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1135 ASSERT_NE(nullptr, capability);
1136 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
1137 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1138 } else {
1139 return;
1140 }
1141 }
1142
1143 /**
1144 * @tc.number : VIDEO_ENCODE_CAPABILITY_3200
1145 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
1146 * @tc.desc : api test
1147 */
1148 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3200, TestSize.Level2)
1149 {
1150 OH_AVErrCode ret = AV_ERR_OK;
1151 int32_t alignment = 0;
1152 ret = OH_AVCapability_GetVideoWidthAlignment(nullptr, &alignment);
1153 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1154 }
1155
1156 /**
1157 * @tc.number : VIDEO_ENCODE_CAPABILITY_3300
1158 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
1159 * @tc.desc : api test
1160 */
1161 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3300, TestSize.Level2)
1162 {
1163 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1164 if (cap) {
1165 OH_AVErrCode ret = AV_ERR_OK;
1166 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1167 ASSERT_NE(nullptr, capability);
1168 int32_t alignment = 0;
1169 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
1170 ASSERT_EQ(AV_ERR_OK, ret);
1171 ASSERT_GE(alignment, 0);
1172 } else {
1173 return;
1174 }
1175 }
1176
1177 /**
1178 * @tc.number : VIDEO_ENCODE_CAPABILITY_3400
1179 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1180 * @tc.desc : api test
1181 */
1182 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3400, TestSize.Level2)
1183 {
1184 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1185 if (cap) {
1186 OH_AVErrCode ret = AV_ERR_OK;
1187 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1188 ASSERT_NE(nullptr, capability);
1189 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
1190 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1191 } else {
1192 return;
1193 }
1194 }
1195
1196 /**
1197 * @tc.number : VIDEO_ENCODE_CAPABILITY_3500
1198 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
1199 * @tc.desc : api test
1200 */
1201 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3500, TestSize.Level2)
1202 {
1203 OH_AVErrCode ret = AV_ERR_OK;
1204 int32_t alignment = 0;
1205 ret = OH_AVCapability_GetVideoHeightAlignment(nullptr, &alignment);
1206 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1207 }
1208
1209 /**
1210 * @tc.number : VIDEO_ENCODE_CAPABILITY_3600
1211 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
1212 * @tc.desc : api test
1213 */
1214 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3600, TestSize.Level2)
1215 {
1216 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1217 if (cap) {
1218 OH_AVErrCode ret = AV_ERR_OK;
1219 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1220 ASSERT_NE(nullptr, capability);
1221 int32_t alignment = 0;
1222 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
1223 ASSERT_EQ(AV_ERR_OK, ret);
1224 ASSERT_GE(alignment, 0);
1225 } else {
1226 return;
1227 }
1228 }
1229
1230 /**
1231 * @tc.number : VIDEO_ENCODE_CAPABILITY_3700
1232 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1233 * @tc.desc : api test
1234 */
1235 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3700, TestSize.Level2)
1236 {
1237 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1238 if (cap) {
1239 OH_AVErrCode ret = AV_ERR_OK;
1240 OH_AVRange range;
1241 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1242 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1243 ASSERT_NE(nullptr, capability);
1244 ret = OH_AVCapability_GetVideoWidthRangeForHeight(nullptr, DEFAULT_WIDTH, &range);
1245 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1246 } else {
1247 return;
1248 }
1249 }
1250
1251 /**
1252 * @tc.number : VIDEO_ENCODE_CAPABILITY_3800
1253 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1254 * @tc.desc : api test
1255 */
1256 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3800, TestSize.Level2)
1257 {
1258 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1259 if (cap) {
1260 OH_AVErrCode ret = AV_ERR_OK;
1261 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1262 ASSERT_NE(nullptr, capability);
1263 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_WIDTH, nullptr);
1264 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1265 } else {
1266 return;
1267 }
1268 }
1269
1270 /**
1271 * @tc.number : VIDEO_ENCODE_CAPABILITY_3900
1272 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
1273 * @tc.desc : api test
1274 */
1275 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_3900, TestSize.Level2)
1276 {
1277 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1278 if (cap) {
1279 OH_AVErrCode ret = AV_ERR_OK;
1280 OH_AVRange range;
1281 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1282 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1283 ASSERT_NE(nullptr, capability);
1284 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
1285 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1286 } else {
1287 return;
1288 }
1289 }
1290
1291 /**
1292 * @tc.number : VIDEO_ENCODE_CAPABILITY_4100
1293 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1294 * @tc.desc : api test
1295 */
1296 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4100, TestSize.Level2)
1297 {
1298 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1299 if (cap) {
1300 OH_AVErrCode ret = AV_ERR_OK;
1301 OH_AVRange range;
1302 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1303 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1304 ASSERT_NE(nullptr, capability);
1305 ret = OH_AVCapability_GetVideoHeightRangeForWidth(nullptr, DEFAULT_HEIGHT, &range);
1306 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1307 } else {
1308 return;
1309 }
1310 }
1311
1312 /**
1313 * @tc.number : VIDEO_ENCODE_CAPABILITY_4200
1314 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1315 * @tc.desc : api test
1316 */
1317 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4200, TestSize.Level2)
1318 {
1319 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1320 if (cap) {
1321 OH_AVErrCode ret = AV_ERR_OK;
1322 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1323 ASSERT_NE(nullptr, capability);
1324 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_HEIGHT, nullptr);
1325 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1326 } else {
1327 return;
1328 }
1329 }
1330
1331 /**
1332 * @tc.number : VIDEO_ENCODE_CAPABILITY_4300
1333 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
1334 * @tc.desc : api test
1335 */
1336 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4300, TestSize.Level2)
1337 {
1338 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1339 if (cap) {
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_GetVideoHeightRangeForWidth(capability, 0, &range);
1346 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1347 } else {
1348 return;
1349 }
1350 }
1351
1352 /**
1353 * @tc.number : VIDEO_ENCODE_CAPABILITY_4500
1354 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1355 * @tc.desc : api test
1356 */
1357 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4500, TestSize.Level2)
1358 {
1359 OH_AVErrCode ret = AV_ERR_OK;
1360 OH_AVRange range;
1361 ret = OH_AVCapability_GetVideoWidthRange(nullptr, &range);
1362 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1363 }
1364
1365 /**
1366 * @tc.number : VIDEO_ENCODE_CAPABILITY_4600
1367 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
1368 * @tc.desc : api test
1369 */
1370 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4600, TestSize.Level2)
1371 {
1372 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1373 if (cap) {
1374 OH_AVErrCode ret = AV_ERR_OK;
1375 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1376 ASSERT_NE(nullptr, capability);
1377 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
1378 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1379 } else {
1380 return;
1381 }
1382 }
1383
1384 /**
1385 * @tc.number : VIDEO_ENCODE_CAPABILITY_4800
1386 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1387 * @tc.desc : api test
1388 */
1389 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4800, TestSize.Level2)
1390 {
1391 OH_AVErrCode ret = AV_ERR_OK;
1392 OH_AVRange range;
1393 ret = OH_AVCapability_GetVideoHeightRange(nullptr, &range);
1394 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1395 }
1396
1397 /**
1398 * @tc.number : VIDEO_ENCODE_CAPABILITY_4900
1399 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
1400 * @tc.desc : api test
1401 */
1402 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_4900, TestSize.Level2)
1403 {
1404 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1405 if (cap) {
1406 OH_AVErrCode ret = AV_ERR_OK;
1407 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1408 ASSERT_NE(nullptr, capability);
1409 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
1410 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1411 } else {
1412 return;
1413 }
1414 }
1415
1416 /**
1417 * @tc.number : VIDEO_ENCODE_CAPABILITY_9800
1418 * @tc.name : configure encoder with illegal width and height
1419 * @tc.desc : api test
1420 */
1421 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_9800, TestSize.Level2)
1422 {
1423 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1424 if (cap) {
1425 OH_AVErrCode ret = AV_ERR_OK;
1426 OH_AVRange widthRange;
1427 OH_AVRange heightRange;
1428 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1429 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1430 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1431 ASSERT_NE(nullptr, capability);
1432 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
1433 ASSERT_EQ(AV_ERR_OK, ret);
1434 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
1435 ASSERT_EQ(AV_ERR_OK, ret);
1436 } else {
1437 return;
1438 }
1439 }
1440
1441 /**
1442 * @tc.number : VIDEO_ENCODE_CAPABILITY_5100
1443 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1444 * @tc.desc : api test
1445 */
1446 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5100, TestSize.Level2)
1447 {
1448 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1449 if (cap) {
1450 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1451 ASSERT_NE(nullptr, capability);
1452 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
1453 } else {
1454 return;
1455 }
1456 }
1457
1458 /**
1459 * @tc.number : VIDEO_ENCODE_CAPABILITY_5200
1460 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1461 * @tc.desc : api test
1462 */
1463 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5200, TestSize.Level2)
1464 {
1465 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1466 if (cap) {
1467 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1468 ASSERT_NE(nullptr, capability);
1469 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
1470 } else {
1471 return;
1472 }
1473 }
1474
1475 /**
1476 * @tc.number : VIDEO_ENCODE_CAPABILITY_5300
1477 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
1478 * @tc.desc : api test
1479 */
1480 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5300, TestSize.Level2)
1481 {
1482 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1483 }
1484
1485 /**
1486 * @tc.number : VIDEO_ENCODE_CAPABILITY_5400
1487 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
1488 * @tc.desc : api test
1489 */
1490 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5400, TestSize.Level2)
1491 {
1492 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1493 if (cap) {
1494 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1495 ASSERT_NE(nullptr, capability);
1496 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
1497 } else {
1498 return;
1499 }
1500 }
1501
1502 /**
1503 * @tc.number : VIDEO_ENCODE_CAPABILITY_5500
1504 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1505 * @tc.desc : api test
1506 */
1507 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5500, TestSize.Level2)
1508 {
1509 OH_AVErrCode ret = AV_ERR_OK;
1510 OH_AVRange range;
1511 ret = OH_AVCapability_GetVideoFrameRateRange(nullptr, &range);
1512 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1513 }
1514
1515 /**
1516 * @tc.number : VIDEO_ENCODE_CAPABILITY_5600
1517 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
1518 * @tc.desc : api test
1519 */
1520 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5600, TestSize.Level2)
1521 {
1522 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1523 if (cap) {
1524 OH_AVErrCode ret = AV_ERR_OK;
1525 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1526 ASSERT_NE(nullptr, capability);
1527 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
1528 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1529 } else {
1530 return;
1531 }
1532 }
1533
1534 /**
1535 * @tc.number : VIDEO_ENCODE_CAPABILITY_5700
1536 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
1537 * @tc.desc : api test
1538 */
1539 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5700, TestSize.Level2)
1540 {
1541 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1542 if (cap) {
1543 OH_AVErrCode ret = AV_ERR_OK;
1544 OH_AVRange range;
1545 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1546 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1547 ASSERT_NE(nullptr, capability);
1548 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
1549 ASSERT_EQ(AV_ERR_OK, ret);
1550 ASSERT_GT(range.minVal, 0);
1551 ASSERT_GT(range.maxVal, 0);
1552 } else {
1553 return;
1554 }
1555 }
1556
1557 /**
1558 * @tc.number : VIDEO_ENCODE_CAPABILITY_5800
1559 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1560 * @tc.desc : api test
1561 */
1562 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5800, TestSize.Level2)
1563 {
1564 OH_AVErrCode ret = AV_ERR_OK;
1565 OH_AVRange range;
1566 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1567 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1568 }
1569
1570 /**
1571 * @tc.number : VIDEO_ENCODE_CAPABILITY_5900
1572 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1573 * @tc.desc : api test
1574 */
1575 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_5900, TestSize.Level2)
1576 {
1577 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1578 if (cap) {
1579 OH_AVErrCode ret = AV_ERR_OK;
1580 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1581 ASSERT_NE(nullptr, capability);
1582 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
1583 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1584 } else {
1585 return;
1586 }
1587 }
1588
1589 /**
1590 * @tc.number : VIDEO_ENCODE_CAPABILITY_6000
1591 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1592 * @tc.desc : api test
1593 */
1594 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6000, TestSize.Level2)
1595 {
1596 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1597 if (cap) {
1598 OH_AVErrCode ret = AV_ERR_OK;
1599 OH_AVRange range;
1600 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1601 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1602 ASSERT_NE(nullptr, capability);
1603 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
1604 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1605 } else {
1606 return;
1607 }
1608 }
1609
1610 /**
1611 * @tc.number : VIDEO_ENCODE_CAPABILITY_6100
1612 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
1613 * @tc.desc : api test
1614 */
1615 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6100, TestSize.Level2)
1616 {
1617 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1618 if (cap) {
1619 OH_AVErrCode ret = AV_ERR_OK;
1620 OH_AVRange range;
1621 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1622 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1623 ASSERT_NE(nullptr, capability);
1624 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
1625 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1626 } else {
1627 return;
1628 }
1629 }
1630
1631 /**
1632 * @tc.number : VIDEO_ENCODE_CAPABILITY_6200
1633 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
1634 * @tc.desc : api test
1635 */
1636 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6200, TestSize.Level2)
1637 {
1638 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1639 if (cap) {
1640 OH_AVErrCode ret = AV_ERR_OK;
1641 OH_AVRange range;
1642 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
1643 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1644 ASSERT_NE(nullptr, capability);
1645 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
1646 ASSERT_EQ(AV_ERR_OK, ret);
1647 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
1648 ASSERT_GT(range.minVal, 0);
1649 ASSERT_GT(range.maxVal, 0);
1650 } else {
1651 return;
1652 }
1653 }
1654
1655 /**
1656 * @tc.number : VIDEO_ENCODE_CAPABILITY_6300
1657 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1658 * @tc.desc : api test
1659 */
1660 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6300, TestSize.Level2)
1661 {
1662 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1663 if (cap) {
1664 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1665 ASSERT_NE(nullptr, capability);
1666 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
1667 } else {
1668 return;
1669 }
1670 }
1671
1672 /**
1673 * @tc.number : VIDEO_ENCODE_CAPABILITY_6400
1674 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1675 * @tc.desc : api test
1676 */
1677 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6400, TestSize.Level2)
1678 {
1679 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1680 if (cap) {
1681 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1682 ASSERT_NE(nullptr, capability);
1683 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
1684 } else {
1685 return;
1686 }
1687 }
1688
1689 /**
1690 * @tc.number : VIDEO_ENCODE_CAPABILITY_6500
1691 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1692 * @tc.desc : api test
1693 */
1694 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6500, TestSize.Level2)
1695 {
1696 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1697 if (cap) {
1698 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1699 ASSERT_NE(nullptr, capability);
1700 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
1701 } else {
1702 return;
1703 }
1704 }
1705
1706 /**
1707 * @tc.number : VIDEO_ENCODE_CAPABILITY_6600
1708 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
1709 * @tc.desc : api test
1710 */
1711 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6600, TestSize.Level2)
1712 {
1713 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1714 }
1715
1716 /**
1717 * @tc.number : VIDEO_ENCODE_CAPABILITY_6700
1718 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
1719 * @tc.desc : api test
1720 */
1721 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6700, TestSize.Level2)
1722 {
1723 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1724 if (cap) {
1725 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1726 ASSERT_NE(nullptr, capability);
1727 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
1728 } else {
1729 return;
1730 }
1731 }
1732
1733 /**
1734 * @tc.number : VIDEO_ENCODE_CAPABILITY_6800
1735 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1736 * @tc.desc : api test
1737 */
1738 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6800, TestSize.Level2)
1739 {
1740 OH_AVErrCode ret = AV_ERR_OK;
1741 const int32_t *pixelFormat = nullptr;
1742 uint32_t pixelFormatNum = 0;
1743 ret = OH_AVCapability_GetVideoSupportedPixelFormats(nullptr, &pixelFormat, &pixelFormatNum);
1744 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1745 }
1746
1747 /**
1748 * @tc.number : VIDEO_ENCODE_CAPABILITY_6900
1749 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1750 * @tc.desc : api test
1751 */
1752 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_6900, TestSize.Level2)
1753 {
1754 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1755 if (cap) {
1756 OH_AVErrCode ret = AV_ERR_OK;
1757 uint32_t pixelFormatNum = 0;
1758 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1759 ASSERT_NE(nullptr, capability);
1760 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
1761 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1762 } else {
1763 return;
1764 }
1765 }
1766
1767 /**
1768 * @tc.number : VIDEO_ENCODE_CAPABILITY_7000
1769 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
1770 * @tc.desc : api test
1771 */
1772 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7000, TestSize.Level2)
1773 {
1774 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1775 if (cap) {
1776 OH_AVErrCode ret = AV_ERR_OK;
1777 const int32_t *pixelFormat = nullptr;
1778 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1779 ASSERT_NE(nullptr, capability);
1780 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
1781 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1782 } else {
1783 return;
1784 }
1785 }
1786
1787 /**
1788 * @tc.number : VIDEO_ENCODE_CAPABILITY_7100
1789 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
1790 * @tc.desc : api test
1791 */
1792 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7100, TestSize.Level2)
1793 {
1794 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1795 if (cap) {
1796 OH_AVErrCode ret = AV_ERR_OK;
1797 const int32_t *pixelFormat = nullptr;
1798 uint32_t pixelFormatNum = 0;
1799 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1800 ASSERT_NE(nullptr, capability);
1801 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
1802 ASSERT_NE(nullptr, pixelFormat);
1803 ASSERT_GT(pixelFormatNum, 0);
1804 ASSERT_EQ(AV_ERR_OK, ret);
1805 for (int i = 0; i < pixelFormatNum; i++) {
1806 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1807 ASSERT_NE(nullptr, venc_);
1808 format = OH_AVFormat_Create();
1809 ASSERT_NE(nullptr, format);
1810 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1811 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1812 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1813 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1814 EXPECT_GE(pixelFormat[i], 0);
1815 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
1816 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
1817 OH_AVFormat_Destroy(format);
1818 OH_VideoEncoder_Destroy(venc_);
1819 }
1820 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1821 ASSERT_NE(nullptr, venc_);
1822 format = OH_AVFormat_Create();
1823 ASSERT_NE(nullptr, format);
1824 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1825 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1826 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1827 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1828 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
1829 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoEncoder_Configure(venc_, format));
1830 } else {
1831 return;
1832 }
1833 }
1834
1835 /**
1836 * @tc.number : VIDEO_ENCODE_CAPABILITY_7200
1837 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1838 * @tc.desc : api test
1839 */
1840 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7200, TestSize.Level2)
1841 {
1842 OH_AVErrCode ret = AV_ERR_OK;
1843 const int32_t *profiles = nullptr;
1844 uint32_t profileNum = 0;
1845 ret = OH_AVCapability_GetSupportedProfiles(nullptr, &profiles, &profileNum);
1846 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1847 }
1848
1849 /**
1850 * @tc.number : VIDEO_ENCODE_CAPABILITY_7300
1851 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1852 * @tc.desc : api test
1853 */
1854 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7300, TestSize.Level2)
1855 {
1856 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1857 if (cap) {
1858 OH_AVErrCode ret = AV_ERR_OK;
1859 uint32_t profileNum = 0;
1860 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1861 ASSERT_NE(nullptr, capability);
1862 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
1863 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1864 } else {
1865 return;
1866 }
1867 }
1868
1869 /**
1870 * @tc.number : VIDEO_ENCODE_CAPABILITY_7400
1871 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
1872 * @tc.desc : api test
1873 */
1874 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7400, TestSize.Level2)
1875 {
1876 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1877 if (cap) {
1878 OH_AVErrCode ret = AV_ERR_OK;
1879 const int32_t *profiles = nullptr;
1880 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1881 ASSERT_NE(nullptr, capability);
1882 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
1883 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1884 } else {
1885 return;
1886 }
1887 }
1888
1889 /**
1890 * @tc.number : VIDEO_ENCODE_CAPABILITY_7500
1891 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
1892 * @tc.desc : api test
1893 */
1894 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7500, TestSize.Level2)
1895 {
1896 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1897 if (cap) {
1898 OH_AVErrCode ret = AV_ERR_OK;
1899 const int32_t *profiles = nullptr;
1900 uint32_t profileNum = 0;
1901 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1902 ASSERT_NE(nullptr, capability);
1903 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
1904 ASSERT_EQ(AV_ERR_OK, ret);
1905 ASSERT_NE(nullptr, profiles);
1906 ASSERT_EQ(profileNum, MAX_PROFILE_NUM);
1907 for (int i = 0; i < profileNum; i++) {
1908 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1909 ASSERT_NE(nullptr, venc_);
1910 format = OH_AVFormat_Create();
1911 ASSERT_NE(nullptr, format);
1912 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1913 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1914 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1915 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1916 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1917 EXPECT_GE(profiles[i], 0);
1918 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, profiles[i]);
1919 ret = OH_VideoEncoder_Configure(venc_, format);
1920 if (ret != AV_ERR_OK) {
1921 cout << profiles[i] << " profile cant configure" << endl;
1922 }
1923 EXPECT_EQ(AV_ERR_OK, ret);
1924 OH_AVFormat_Destroy(format);
1925 OH_VideoEncoder_Destroy(venc_);
1926 }
1927 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
1928 ASSERT_NE(nullptr, venc_);
1929 format = OH_AVFormat_Create();
1930 ASSERT_NE(nullptr, format);
1931 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1932 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1933 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1934 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
1935 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
1936 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_MAIN + AVC_PROFILE_MAIN);
1937 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
1938 } else {
1939 return;
1940 }
1941 }
1942
1943 /**
1944 * @tc.number : VIDEO_ENCODE_CAPABILITY_7600
1945 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1946 * @tc.desc : api test
1947 */
1948 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7600, TestSize.Level2)
1949 {
1950 OH_AVErrCode ret = AV_ERR_OK;
1951 const int32_t *levels = nullptr;
1952 uint32_t levelNum = 0;
1953 ret = OH_AVCapability_GetSupportedLevelsForProfile(nullptr, AVC_PROFILE_BASELINE, &levels, &levelNum);
1954 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1955 }
1956
1957 /**
1958 * @tc.number : VIDEO_ENCODE_CAPABILITY_7700
1959 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1960 * @tc.desc : api test
1961 */
1962 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7700, TestSize.Level2)
1963 {
1964 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1965 if (cap) {
1966 OH_AVErrCode ret = AV_ERR_OK;
1967 const int32_t *levels = nullptr;
1968 uint32_t levelNum = 0;
1969 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1970 ASSERT_NE(nullptr, capability);
1971 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, &levels, &levelNum);
1972 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1973 } else {
1974 return;
1975 }
1976 }
1977
1978 /**
1979 * @tc.number : VIDEO_ENCODE_CAPABILITY_7800
1980 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
1981 * @tc.desc : api test
1982 */
1983 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7800, TestSize.Level2)
1984 {
1985 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1986 if (cap) {
1987 OH_AVErrCode ret = AV_ERR_OK;
1988 uint32_t levelNum = 0;
1989 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1990 ASSERT_NE(nullptr, capability);
1991 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, nullptr, &levelNum);
1992 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
1993 } else {
1994 return;
1995 }
1996 }
1997
1998 /**
1999 * @tc.number : VIDEO_ENCODE_CAPABILITY_7900
2000 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
2001 * @tc.desc : api test
2002 */
2003 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_7900, TestSize.Level2)
2004 {
2005 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2006 if (cap) {
2007 OH_AVErrCode ret = AV_ERR_OK;
2008 const int32_t *levels = nullptr;
2009 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2010 ASSERT_NE(nullptr, capability);
2011 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, nullptr);
2012 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2013 } else {
2014 return;
2015 }
2016 }
2017
2018 /**
2019 * @tc.number : VIDEO_ENCODE_CAPABILITY_8000
2020 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
2021 * @tc.desc : api test
2022 */
2023 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8000, TestSize.Level2)
2024 {
2025 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2026 if (cap) {
2027 OH_AVErrCode ret = AV_ERR_OK;
2028 const int32_t *levels = nullptr;
2029 uint32_t levelNum = 0;
2030 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2031 ASSERT_NE(nullptr, capability);
2032 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, AVC_PROFILE_BASELINE, &levels, &levelNum);
2033 ASSERT_EQ(AV_ERR_OK, ret);
2034 ASSERT_NE(nullptr, levels);
2035 ASSERT_GT(levelNum, 0);
2036 for (int i = 0; i < levelNum; i++) {
2037 ASSERT_GE(levels[i], 0);
2038 }
2039 } else {
2040 return;
2041 }
2042 }
2043
2044 /**
2045 * @tc.number : VIDEO_ENCODE_CAPABILITY_8100
2046 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2047 * @tc.desc : api test
2048 */
2049 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8100, TestSize.Level2)
2050 {
2051 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(nullptr, AVC_PROFILE_BASELINE, 1));
2052 }
2053
2054 /**
2055 * @tc.number : VIDEO_ENCODE_CAPABILITY_8200
2056 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
2057 * @tc.desc : api test
2058 */
2059 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8200, TestSize.Level2)
2060 {
2061 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2062 if (cap) {
2063 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2064 ASSERT_NE(nullptr, capability);
2065 ASSERT_EQ(false, OH_AVCapability_AreProfileAndLevelSupported(capability, 1, 1));
2066 } else {
2067 return;
2068 }
2069 }
2070
2071 /**
2072 * @tc.number : VIDEO_ENCODE_CAPABILITY_8300
2073 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
2074 * @tc.desc : api test
2075 */
2076 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8300, TestSize.Level2)
2077 {
2078 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2079 if (cap) {
2080 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
2081 ASSERT_NE(nullptr, capability);
2082 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, AVC_PROFILE_BASELINE, 1));
2083 } else {
2084 return;
2085 }
2086 }
2087
2088 /**
2089 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0100
2090 * @tc.name : OH_AVCodec_GetCapability
2091 * @tc.desc : api test
2092 */
2093 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0100, TestSize.Level2)
2094 {
2095 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2096 if (cap) {
2097 ASSERT_NE(nullptr, OH_AVCodec_GetCapability(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true));
2098 } else {
2099 return;
2100 }
2101 }
2102
2103 /**
2104 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0200
2105 * @tc.name : OH_AVCodec_GetCapabilityByCategory param correct
2106 * @tc.desc : api test
2107 */
2108 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0200, TestSize.Level2)
2109 {
2110 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2111 if (cap) {
2112 ASSERT_NE(nullptr, OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE));
2113 } else {
2114 return;
2115 }
2116 }
2117
2118 /**
2119 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0300
2120 * @tc.name : OH_AVCapability_IsHardware param correct
2121 * @tc.desc : api test
2122 */
2123 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0300, TestSize.Level2)
2124 {
2125 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2126 if (cap) {
2127 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2128 ASSERT_NE(nullptr, capability);
2129 ASSERT_EQ(true, OH_AVCapability_IsHardware(capability));
2130 } else {
2131 return;
2132 }
2133 }
2134
2135 /**
2136 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0400
2137 * @tc.name : OH_AVCapability_GetName param correct
2138 * @tc.desc : api test
2139 */
2140 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0400, TestSize.Level2)
2141 {
2142 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2143 if (cap) {
2144 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2145 ASSERT_NE(nullptr, capability);
2146 const char *name = OH_AVCapability_GetName(capability);
2147 ASSERT_NE(name, nullptr);
2148 ASSERT_GT(strlen(name), 0);
2149 } else {
2150 return;
2151 }
2152 }
2153
2154 /**
2155 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0500
2156 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param error
2157 * @tc.desc : api test
2158 */
2159
2160 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0500, TestSize.Level2)
2161 {
2162 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2163 if (cap) {
2164 OH_AVErrCode ret = AV_ERR_OK;
2165
2166 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2167 ASSERT_NE(nullptr, capability);
2168
2169 ret = OH_AVCapability_GetEncoderBitrateRange(capability, nullptr);
2170 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2171 } else {
2172 return;
2173 }
2174 }
2175
2176 /**
2177 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0600
2178 * @tc.name : OH_AVCapability_GetEncoderBitrateRange param correct
2179 * @tc.desc : api test
2180 */
2181 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0600, TestSize.Level2)
2182 {
2183 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2184 if (cap) {
2185 OH_AVErrCode ret = AV_ERR_OK;
2186 OH_AVRange range;
2187 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2188 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2189 ASSERT_NE(nullptr, capability);
2190 ret = OH_AVCapability_GetEncoderBitrateRange(capability, &range);
2191 ASSERT_EQ(AV_ERR_OK, ret);
2192 cout << "max val " << range.maxVal << " min val " << range.minVal << endl;
2193 ASSERT_GE(range.minVal, 0);
2194 ASSERT_GT(range.maxVal, 0);
2195 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2196 ASSERT_NE(nullptr, venc_);
2197 format = OH_AVFormat_Create();
2198 ASSERT_NE(nullptr, format);
2199 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2200 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2201 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2202 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, range.minVal - 1);
2203 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
2204 OH_VideoEncoder_Destroy(venc_);
2205 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2206 ASSERT_NE(nullptr, venc_);
2207 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, range.maxVal + 1);
2208 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
2209 } else {
2210 return;
2211 }
2212 }
2213
2214 /**
2215 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_07
2216 * 00
2217 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2218 * @tc.desc : api test
2219 */
2220 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0700, TestSize.Level2)
2221 {
2222 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2223 if (cap) {
2224 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2225 ASSERT_NE(nullptr, capability);
2226 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2227 ASSERT_NE(nullptr, venc_);
2228 format = OH_AVFormat_Create();
2229 ASSERT_NE(nullptr, format);
2230 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2231 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2232 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2233 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2234 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
2235
2236 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_CBR);
2237 EXPECT_EQ(isSupported, true);
2238 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CBR);
2239 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2240 OH_VideoEncoder_Destroy(venc_);
2241 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2242 ASSERT_NE(nullptr, venc_);
2243 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_VBR);
2244 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2245 } else {
2246 return;
2247 }
2248 }
2249
2250 /**
2251 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5200
2252 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2253 * @tc.desc : api test
2254 */
2255 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5200, TestSize.Level2)
2256 {
2257 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2258 if (cap) {
2259 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2260 ASSERT_NE(nullptr, capability);
2261 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2262 ASSERT_NE(nullptr, venc_);
2263 format = OH_AVFormat_Create();
2264 ASSERT_NE(nullptr, format);
2265 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2266 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2267 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2268 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2269 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
2270 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capability, BITRATE_MODE_VBR);
2271 EXPECT_EQ(isSupported, true);
2272 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_VBR);
2273 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2274 } else {
2275 return;
2276 }
2277 }
2278
2279 /**
2280 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5300
2281 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2282 * @tc.desc : api test
2283 */
2284 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5300, TestSize.Level2)
2285 {
2286 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2287 if (cap) {
2288 OH_AVCapability *capa = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2289 ASSERT_NE(nullptr, capa);
2290 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
2291 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2292 ASSERT_NE(nullptr, venc_);
2293 format = OH_AVFormat_Create();
2294 ASSERT_NE(nullptr, format);
2295 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2296 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2297 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2298 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2299 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, DEFAULT_QUALITY);
2300 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
2301 EXPECT_EQ(isSupported, true);
2302 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CQ);
2303 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
2304 } else {
2305 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(capa, BITRATE_MODE_CQ);
2306 EXPECT_EQ(isSupported, false);
2307 }
2308 } else {
2309 return;
2310 }
2311 }
2312
2313 /**
2314 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5400
2315 * @tc.name : OH_AVCapability_IsEncoderBitrateModeSupported param correct
2316 * @tc.desc : api test
2317 */
2318 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5400, TestSize.Level2)
2319 {
2320 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2321 if (cap) {
2322 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2323 ASSERT_NE(nullptr, capability);
2324 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
2325 ASSERT_NE(nullptr, venc_);
2326 format = OH_AVFormat_Create();
2327 ASSERT_NE(nullptr, format);
2328 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
2329 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
2330 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
2331 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
2332 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
2333 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, BITRATE_MODE_CQ + BITRATE_MODE_CQ);
2334 EXPECT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
2335 } else {
2336 return;
2337 }
2338 }
2339
2340 /**
2341 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0800
2342 * @tc.name : OH_AVCapability_GetEncoderQualityRange param error
2343 * @tc.desc : api test
2344 */
2345 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0800, TestSize.Level2)
2346 {
2347 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2348 if (cap) {
2349 OH_AVErrCode ret = AV_ERR_OK;
2350 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2351 ASSERT_NE(nullptr, capability);
2352 ret = OH_AVCapability_GetEncoderQualityRange(capability, nullptr);
2353 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2354 } else {
2355 return;
2356 }
2357 }
2358
2359 /**
2360 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_0900
2361 * @tc.name : OH_AVCapability_GetEncoderQualityRange param correct
2362 * @tc.desc : api test
2363 */
2364 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_0900, TestSize.Level2)
2365 {
2366 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2367 if (cap) {
2368 OH_AVErrCode ret = AV_ERR_OK;
2369 OH_AVRange range;
2370 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2371 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2372 ASSERT_NE(nullptr, capability);
2373 ret = OH_AVCapability_GetEncoderQualityRange(capability, &range);
2374 ASSERT_EQ(AV_ERR_OK, ret);
2375 ASSERT_EQ(range.minVal, 0);
2376 ASSERT_EQ(range.maxVal, MAX_QUALITY);
2377 } else {
2378 return;
2379 }
2380 }
2381
2382 /**
2383 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1000
2384 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param error
2385 * @tc.desc : api test
2386 */
2387 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1000, TestSize.Level2)
2388 {
2389 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2390 if (cap) {
2391 OH_AVErrCode ret = AV_ERR_OK;
2392 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2393 ASSERT_NE(nullptr, capability);
2394 ret = OH_AVCapability_GetEncoderComplexityRange(capability, nullptr);
2395 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2396 } else {
2397 return;
2398 }
2399 }
2400
2401 /**
2402 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1100
2403 * @tc.name : OH_AVCapability_GetEncoderComplexityRange param correct
2404 * @tc.desc : api test
2405 */
2406 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1100, TestSize.Level2)
2407 {
2408 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2409 if (cap) {
2410 OH_AVErrCode ret = AV_ERR_OK;
2411 OH_AVRange range;
2412 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2413 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2414 ASSERT_NE(nullptr, capability);
2415 ret = OH_AVCapability_GetEncoderComplexityRange(capability, &range);
2416 ASSERT_EQ(AV_ERR_OK, ret);
2417 } else {
2418 return;
2419 }
2420 }
2421
2422 /**
2423 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1200
2424 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param error
2425 * @tc.desc : api test
2426 */
2427 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1200, TestSize.Level2)
2428 {
2429 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2430 if (cap) {
2431 OH_AVErrCode ret = AV_ERR_OK;
2432 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2433 ASSERT_NE(nullptr, capability);
2434 ret = OH_AVCapability_GetVideoWidthAlignment(capability, nullptr);
2435 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2436 } else {
2437 return;
2438 }
2439 }
2440
2441 /**
2442 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1300
2443 * @tc.name : OH_AVCapability_GetVideoWidthAlignment param correct
2444 * @tc.desc : api test
2445 */
2446 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1300, TestSize.Level2)
2447 {
2448 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2449 if (cap) {
2450 OH_AVErrCode ret = AV_ERR_OK;
2451 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2452 ASSERT_NE(nullptr, capability);
2453 int32_t alignment = 0;
2454 ret = OH_AVCapability_GetVideoWidthAlignment(capability, &alignment);
2455 ASSERT_EQ(AV_ERR_OK, ret);
2456 ASSERT_GE(alignment, 0);
2457 } else {
2458 return;
2459 }
2460 }
2461
2462 /**
2463 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1400
2464 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param error
2465 * @tc.desc : api test
2466 */
2467 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1400, TestSize.Level2)
2468 {
2469 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2470 if (cap) {
2471 OH_AVErrCode ret = AV_ERR_OK;
2472 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2473 ASSERT_NE(nullptr, capability);
2474 ret = OH_AVCapability_GetVideoHeightAlignment(capability, nullptr);
2475 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2476 } else {
2477 return;
2478 }
2479 }
2480
2481 /**
2482 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1500
2483 * @tc.name : OH_AVCapability_GetVideoHeightAlignment param correct
2484 * @tc.desc : api test
2485 */
2486 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1500, TestSize.Level2)
2487 {
2488 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2489 if (cap) {
2490 OH_AVErrCode ret = AV_ERR_OK;
2491 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2492 ASSERT_NE(nullptr, capability);
2493 int32_t alignment = 0;
2494 ret = OH_AVCapability_GetVideoHeightAlignment(capability, &alignment);
2495 ASSERT_EQ(AV_ERR_OK, ret);
2496 ASSERT_GE(alignment, 0);
2497 } else {
2498 return;
2499 }
2500 }
2501
2502 /**
2503 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1600
2504 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
2505 * @tc.desc : api test
2506 */
2507 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1600, TestSize.Level2)
2508 {
2509 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2510 if (cap) {
2511 OH_AVErrCode ret = AV_ERR_OK;
2512 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2513 ASSERT_NE(nullptr, capability);
2514 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, DEFAULT_WIDTH, nullptr);
2515 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2516 } else {
2517 return;
2518 }
2519 }
2520
2521 /**
2522 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1700
2523 * @tc.name : OH_AVCapability_GetVideoWidthRangeForHeight param error
2524 * @tc.desc : api test
2525 */
2526 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1700, TestSize.Level2)
2527 {
2528 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2529 if (cap) {
2530 OH_AVErrCode ret = AV_ERR_OK;
2531 OH_AVRange range;
2532 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2533 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2534 ASSERT_NE(nullptr, capability);
2535 ret = OH_AVCapability_GetVideoWidthRangeForHeight(capability, 0, &range);
2536 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2537 } else {
2538 return;
2539 }
2540 }
2541
2542 /**
2543 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_1900
2544 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
2545 * @tc.desc : api test
2546 */
2547 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_1900, TestSize.Level2)
2548 {
2549 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2550 if (cap) {
2551 OH_AVErrCode ret = AV_ERR_OK;
2552 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2553 ASSERT_NE(nullptr, capability);
2554 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_HEIGHT, nullptr);
2555 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2556 } else {
2557 return;
2558 }
2559 }
2560
2561 /**
2562 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2000
2563 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param error
2564 * @tc.desc : api test
2565 */
2566 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2000, TestSize.Level2)
2567 {
2568 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2569 if (cap) {
2570 OH_AVErrCode ret = AV_ERR_OK;
2571 OH_AVRange range;
2572 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2573 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2574 ASSERT_NE(nullptr, capability);
2575 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, 0, &range);
2576 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2577 } else {
2578 return;
2579 }
2580 }
2581
2582 /**
2583 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2100
2584 * @tc.name : OH_AVCapability_GetVideoHeightRangeForWidth param correct
2585 * @tc.desc : api test
2586 */
2587 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2100, TestSize.Level2)
2588 {
2589 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2590 if (cap) {
2591 OH_AVErrCode ret = AV_ERR_OK;
2592 OH_AVRange range;
2593 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2594 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2595 ASSERT_NE(nullptr, capability);
2596 ret = OH_AVCapability_GetVideoHeightRangeForWidth(capability, DEFAULT_WIDTH, &range);
2597 ASSERT_EQ(AV_ERR_OK, ret);
2598 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2599 ASSERT_GE(range.minVal, 0);
2600 ASSERT_GT(range.maxVal, 0);
2601 } else {
2602 return;
2603 }
2604 }
2605
2606 /**
2607 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2200
2608 * @tc.name : OH_AVCapability_GetVideoWidthRange param error
2609 * @tc.desc : api test
2610 */
2611 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2200, TestSize.Level2)
2612 {
2613 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2614 if (cap) {
2615 OH_AVErrCode ret = AV_ERR_OK;
2616 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2617 ASSERT_NE(nullptr, capability);
2618 ret = OH_AVCapability_GetVideoWidthRange(capability, nullptr);
2619 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2620 } else {
2621 return;
2622 }
2623 }
2624
2625 /**
2626 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2300
2627 * @tc.name : OH_AVCapability_GetVideoWidthRange param correct
2628 * @tc.desc : api test
2629 */
2630 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2300, TestSize.Level2)
2631 {
2632 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2633 if (cap) {
2634 OH_AVErrCode ret = AV_ERR_OK;
2635 OH_AVRange range;
2636 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2637 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2638 ASSERT_NE(nullptr, capability);
2639 ret = OH_AVCapability_GetVideoWidthRange(capability, &range);
2640 ASSERT_EQ(AV_ERR_OK, ret);
2641 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2642 ASSERT_GE(range.minVal, 0);
2643 ASSERT_GT(range.maxVal, 0);
2644 } else {
2645 return;
2646 }
2647 }
2648
2649 /**
2650 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2400
2651 * @tc.name : OH_AVCapability_GetVideoHeightRange param error
2652 * @tc.desc : api test
2653 */
2654 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2400, TestSize.Level2)
2655 {
2656 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2657 if (cap) {
2658 OH_AVErrCode ret = AV_ERR_OK;
2659 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2660 ASSERT_NE(nullptr, capability);
2661 ret = OH_AVCapability_GetVideoHeightRange(capability, nullptr);
2662 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2663 } else {
2664 return;
2665 }
2666 }
2667
2668 /**
2669 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2500
2670 * @tc.name : OH_AVCapability_GetVideoHeightRange param correct
2671 * @tc.desc : api test
2672 */
2673 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2500, TestSize.Level2)
2674 {
2675 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2676 if (cap) {
2677 OH_AVErrCode ret = AV_ERR_OK;
2678 OH_AVRange range;
2679 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2680 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2681 ASSERT_NE(nullptr, capability);
2682 ret = OH_AVCapability_GetVideoHeightRange(capability, &range);
2683 ASSERT_EQ(AV_ERR_OK, ret);
2684 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2685 ASSERT_GE(range.minVal, 0);
2686 ASSERT_GT(range.maxVal, 0);
2687 } else {
2688 return;
2689 }
2690 }
2691
2692 /**
2693 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2600
2694 * @tc.name : configure encoder with illegal width and height
2695 * @tc.desc : api test
2696 */
2697 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2600, TestSize.Level2)
2698 {
2699 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2700 if (cap) {
2701 OH_AVErrCode ret = AV_ERR_OK;
2702 OH_AVRange widthRange;
2703 OH_AVRange heightRange;
2704 memset_s(&widthRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2705 memset_s(&heightRange, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2706 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2707 ASSERT_NE(nullptr, capability);
2708 ret = OH_AVCapability_GetVideoHeightRange(capability, &heightRange);
2709 ASSERT_EQ(AV_ERR_OK, ret);
2710 ret = OH_AVCapability_GetVideoWidthRange(capability, &widthRange);
2711 ASSERT_EQ(AV_ERR_OK, ret);
2712 ASSERT_GE(heightRange.minVal, 0);
2713 ASSERT_GT(heightRange.maxVal, 0);
2714 ASSERT_GE(widthRange.minVal, 0);
2715 ASSERT_GT(widthRange.maxVal, 0);
2716 } else {
2717 return;
2718 }
2719 }
2720
2721 /**
2722 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2700
2723 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
2724 * @tc.desc : api test
2725 */
2726 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2700, TestSize.Level2)
2727 {
2728 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2729 if (cap) {
2730 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2731 ASSERT_NE(nullptr, capability);
2732 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, 0, DEFAULT_HEIGHT));
2733 } else {
2734 return;
2735 }
2736 }
2737
2738 /**
2739 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2800
2740 * @tc.name : OH_AVCapability_IsVideoSizeSupported param error
2741 * @tc.desc : api test
2742 */
2743 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2800, TestSize.Level2)
2744 {
2745 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2746 if (cap) {
2747 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2748 ASSERT_NE(nullptr, capability);
2749 ASSERT_EQ(false, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, 0));
2750 } else {
2751 return;
2752 }
2753 }
2754
2755 /**
2756 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_2900
2757 * @tc.name : OH_AVCapability_IsVideoSizeSupported param correct
2758 * @tc.desc : api test
2759 */
2760 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_2900, TestSize.Level2)
2761 {
2762 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2763 if (cap) {
2764 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2765 ASSERT_NE(nullptr, capability);
2766 ASSERT_EQ(true, OH_AVCapability_IsVideoSizeSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT));
2767 } else {
2768 return;
2769 }
2770 }
2771
2772 /**
2773 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3000
2774 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param error
2775 * @tc.desc : api test
2776 */
2777 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3000, TestSize.Level2)
2778 {
2779 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2780 if (cap) {
2781 OH_AVErrCode ret = AV_ERR_OK;
2782 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2783 ASSERT_NE(nullptr, capability);
2784 ret = OH_AVCapability_GetVideoFrameRateRange(capability, nullptr);
2785 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2786 } else {
2787 return;
2788 }
2789 }
2790
2791 /**
2792 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3100
2793 * @tc.name : OH_AVCapability_GetVideoFrameRateRange param correct
2794 * @tc.desc : api test
2795 */
2796 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3100, TestSize.Level2)
2797 {
2798 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2799 if (cap) {
2800 OH_AVErrCode ret = AV_ERR_OK;
2801 OH_AVRange range;
2802 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2803 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2804 ASSERT_NE(nullptr, capability);
2805 ret = OH_AVCapability_GetVideoFrameRateRange(capability, &range);
2806 ASSERT_EQ(AV_ERR_OK, ret);
2807 ASSERT_GT(range.minVal, 0);
2808 ASSERT_GT(range.maxVal, 0);
2809 } else {
2810 return;
2811 }
2812 }
2813
2814 /**
2815 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3200
2816 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
2817 * @tc.desc : api test
2818 */
2819 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3200, TestSize.Level2)
2820 {
2821 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2822 if (cap) {
2823 OH_AVErrCode ret = AV_ERR_OK;
2824 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2825 ASSERT_NE(nullptr, capability);
2826 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, nullptr);
2827 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2828 } else {
2829 return;
2830 }
2831 }
2832
2833 /**
2834 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3300
2835 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
2836 * @tc.desc : api test
2837 */
2838 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3300, TestSize.Level2)
2839 {
2840 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2841 if (cap) {
2842 OH_AVErrCode ret = AV_ERR_OK;
2843 OH_AVRange range;
2844 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2845 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2846 ASSERT_NE(nullptr, capability);
2847 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, 0, DEFAULT_HEIGHT, &range);
2848 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2849 } else {
2850 return;
2851 }
2852 }
2853
2854 /**
2855 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3400
2856 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param error
2857 * @tc.desc : api test
2858 */
2859 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3400, TestSize.Level2)
2860 {
2861 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2862 if (cap) {
2863 OH_AVErrCode ret = AV_ERR_OK;
2864 OH_AVRange range;
2865 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2866 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2867 ASSERT_NE(nullptr, capability);
2868 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, 0, &range);
2869 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2870 } else {
2871 return;
2872 }
2873 }
2874
2875 /**
2876 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3500
2877 * @tc.name : OH_AVCapability_GetVideoFrameRateRangeForSize param correct
2878 * @tc.desc : api test
2879 */
2880 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3500, TestSize.Level2)
2881 {
2882 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2883 if (cap) {
2884 OH_AVErrCode ret = AV_ERR_OK;
2885 OH_AVRange range;
2886 memset_s(&range, sizeof(OH_AVRange), 0, sizeof(OH_AVRange));
2887 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2888 ASSERT_NE(nullptr, capability);
2889 ret = OH_AVCapability_GetVideoFrameRateRangeForSize(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, &range);
2890 ASSERT_EQ(AV_ERR_OK, ret);
2891 cout << "minval=" << range.minVal << " maxval=" << range.maxVal << endl;
2892 ASSERT_GT(range.minVal, 0);
2893 ASSERT_GT(range.maxVal, 0);
2894 } else {
2895 return;
2896 }
2897 }
2898
2899 /**
2900 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3600
2901 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2902 * @tc.desc : api test
2903 */
2904 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3600, TestSize.Level2)
2905 {
2906 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2907 if (cap) {
2908 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2909 ASSERT_NE(nullptr, capability);
2910 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, 0, DEFAULT_HEIGHT, 30));
2911 } else {
2912 return;
2913 }
2914 }
2915
2916 /**
2917 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3700
2918 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2919 * @tc.desc : api test
2920 */
2921 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3700, TestSize.Level2)
2922 {
2923 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2924 if (cap) {
2925 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2926 ASSERT_NE(nullptr, capability);
2927 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, 0, 30));
2928 } else {
2929 return;
2930 }
2931 }
2932
2933 /**
2934 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3800
2935 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param error
2936 * @tc.desc : api test
2937 */
2938 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3800, TestSize.Level2)
2939 {
2940 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2941 if (cap) {
2942 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2943 ASSERT_NE(nullptr, capability);
2944 ASSERT_EQ(false, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 0));
2945 } else {
2946 return;
2947 }
2948 }
2949
2950 /**
2951 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_3900
2952 * @tc.name : OH_AVCapability_AreVideoSizeAndFrameRateSupported param correct
2953 * @tc.desc : api test
2954 */
2955 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_3900, TestSize.Level2)
2956 {
2957 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2958 if (cap) {
2959 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2960 ASSERT_NE(nullptr, capability);
2961 ASSERT_EQ(true, OH_AVCapability_AreVideoSizeAndFrameRateSupported(capability, DEFAULT_WIDTH, DEFAULT_HEIGHT, 30));
2962 } else {
2963 return;
2964 }
2965 }
2966
2967 /**
2968 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4000
2969 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
2970 * @tc.desc : api test
2971 */
2972 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4000, TestSize.Level2)
2973 {
2974 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2975 if (cap) {
2976 OH_AVErrCode ret = AV_ERR_OK;
2977 uint32_t pixelFormatNum = 0;
2978 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2979 ASSERT_NE(nullptr, capability);
2980 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, nullptr, &pixelFormatNum);
2981 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
2982 } else {
2983 return;
2984 }
2985 }
2986
2987 /**
2988 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4100
2989 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param error
2990 * @tc.desc : api test
2991 */
2992 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4100, TestSize.Level2)
2993 {
2994 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2995 if (cap) {
2996 OH_AVErrCode ret = AV_ERR_OK;
2997 const int32_t *pixelFormat = nullptr;
2998 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
2999 ASSERT_NE(nullptr, capability);
3000 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, nullptr);
3001 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3002 } else {
3003 return;
3004 }
3005 }
3006
3007 /**
3008 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4200
3009 * @tc.name : OH_AVCapability_GetVideoSupportedPixelFormats param correct
3010 * @tc.desc : api test
3011 */
3012 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4200, TestSize.Level2)
3013 {
3014 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3015 if (cap) {
3016 OH_AVErrCode ret = AV_ERR_OK;
3017 const int32_t *pixelFormat = nullptr;
3018 uint32_t pixelFormatNum = 0;
3019 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3020 ASSERT_NE(nullptr, capability);
3021 ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
3022 ASSERT_NE(nullptr, pixelFormat);
3023 ASSERT_GT(pixelFormatNum, 0);
3024 ASSERT_EQ(AV_ERR_OK, ret);
3025 for (int i = 0; i < pixelFormatNum; i++) {
3026 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3027 ASSERT_NE(nullptr, venc_);
3028 format = OH_AVFormat_Create();
3029 ASSERT_NE(nullptr, format);
3030 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3031 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3032 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3033 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3034 ASSERT_GE(pixelFormat[i], 0);
3035 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, pixelFormat[i]);
3036 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3037 OH_AVFormat_Destroy(format);
3038 OH_VideoEncoder_Destroy(venc_);
3039 }
3040 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3041 ASSERT_NE(nullptr, venc_);
3042 format = OH_AVFormat_Create();
3043 ASSERT_NE(nullptr, format);
3044 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3045 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3046 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3047 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3048 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA + AV_PIXEL_FORMAT_RGBA);
3049 EXPECT_EQ(AV_ERR_UNSUPPORT, OH_VideoEncoder_Configure(venc_, format));
3050 } else {
3051 return;
3052 }
3053 }
3054
3055 /**
3056 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4300
3057 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
3058 * @tc.desc : api test
3059 */
3060 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4300, TestSize.Level2)
3061 {
3062 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3063 if (cap) {
3064 OH_AVErrCode ret = AV_ERR_OK;
3065 uint32_t profileNum = 0;
3066 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3067 ASSERT_NE(nullptr, capability);
3068 ret = OH_AVCapability_GetSupportedProfiles(capability, nullptr, &profileNum);
3069 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3070 } else {
3071 return;
3072 }
3073 }
3074
3075 /**
3076 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4400
3077 * @tc.name : OH_AVCapability_GetSupportedProfiles param error
3078 * @tc.desc : api test
3079 */
3080 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4400, TestSize.Level2)
3081 {
3082 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3083 if (cap) {
3084 OH_AVErrCode ret = AV_ERR_OK;
3085 const int32_t *profiles = nullptr;
3086 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3087 ASSERT_NE(nullptr, capability);
3088 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, nullptr);
3089 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3090 } else {
3091 return;
3092 }
3093 }
3094
3095 /**
3096 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4500
3097 * @tc.name : OH_AVCapability_GetSupportedProfiles param correct
3098 * @tc.desc : api test
3099 */
3100 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4500, TestSize.Level2)
3101 {
3102 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3103 if (cap) {
3104 OH_AVErrCode ret = AV_ERR_OK;
3105 const int32_t *profiles = nullptr;
3106 uint32_t profileNum = 0;
3107 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3108 ASSERT_NE(nullptr, capability);
3109 ret = OH_AVCapability_GetSupportedProfiles(capability, &profiles, &profileNum);
3110 ASSERT_EQ(AV_ERR_OK, ret);
3111 ASSERT_NE(nullptr, profiles);
3112 ASSERT_GT(profileNum, 0);
3113 for (int i = 0; i < profileNum; i++) {
3114 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3115 ASSERT_NE(nullptr, venc_);
3116 format = OH_AVFormat_Create();
3117 ASSERT_NE(nullptr, format);
3118 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3119 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3120 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
3121 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3122 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3123 EXPECT_GE(profiles[i], 0);
3124 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, profiles[i]);
3125 ret = OH_VideoEncoder_Configure(venc_, format);
3126 if (ret != AV_ERR_OK) {
3127 cout << profiles[i] << " profile cant configure" << endl;
3128 }
3129 EXPECT_EQ(AV_ERR_OK, ret);
3130 OH_AVFormat_Destroy(format);
3131 OH_VideoEncoder_Destroy(venc_);
3132 }
3133 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3134 ASSERT_NE(nullptr, venc_);
3135 format = OH_AVFormat_Create();
3136 ASSERT_NE(nullptr, format);
3137 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3138 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3139 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3140 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3141 int32_t illegalProfile = HEVC_PROFILE_MAIN_10_HDR10_PLUS + HEVC_PROFILE_MAIN_10_HDR10_PLUS;
3142 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, illegalProfile);
3143 ret = OH_VideoEncoder_Configure(venc_, format);
3144 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3145 } else {
3146 return;
3147 }
3148 }
3149
3150 /**
3151 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4600
3152 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
3153 * @tc.desc : api test
3154 */
3155 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4600, TestSize.Level2)
3156 {
3157 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3158 if (cap) {
3159 OH_AVErrCode ret = AV_ERR_OK;
3160 const int32_t **levels = nullptr;
3161 uint32_t levelNum = 0;
3162 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3163 ASSERT_NE(nullptr, capability);
3164 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, 1, levels, &levelNum);
3165 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3166 } else {
3167 return;
3168 }
3169 }
3170
3171 /**
3172 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4700
3173 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
3174 * @tc.desc : api test
3175 */
3176 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4700, TestSize.Level2)
3177 {
3178 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3179 if (cap) {
3180 OH_AVErrCode ret = AV_ERR_OK;
3181 uint32_t levelNum = 0;
3182 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3183 ASSERT_NE(nullptr, capability);
3184 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, HEVC_PROFILE_MAIN, nullptr, &levelNum);
3185 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3186 } else {
3187 return;
3188 }
3189 }
3190
3191 /**
3192 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4800
3193 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param error
3194 * @tc.desc : api test
3195 */
3196 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4800, TestSize.Level2)
3197 {
3198 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3199 if (cap) {
3200 OH_AVErrCode ret = AV_ERR_OK;
3201 const int32_t *levels = nullptr;
3202 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3203 ASSERT_NE(nullptr, capability);
3204 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, HEVC_PROFILE_MAIN, &levels, nullptr);
3205 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
3206 } else {
3207 return;
3208 }
3209 }
3210
3211 /**
3212 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_4900
3213 * @tc.name : OH_AVCapability_GetSupportedLevelsForProfile param correct
3214 * @tc.desc : api test
3215 */
3216 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_4900, TestSize.Level2)
3217 {
3218 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3219 if (cap) {
3220 OH_AVErrCode ret = AV_ERR_OK;
3221 const int32_t *levels = nullptr;
3222 uint32_t levelNum = 0;
3223 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3224 ASSERT_NE(nullptr, capability);
3225 ret = OH_AVCapability_GetSupportedLevelsForProfile(capability, HEVC_PROFILE_MAIN, &levels, &levelNum);
3226 ASSERT_EQ(AV_ERR_OK, ret);
3227 ASSERT_NE(nullptr, levels);
3228 ASSERT_GT(levelNum, 0);
3229 for (int i = 0; i < levelNum; i++) {
3230 ASSERT_GE(levels[i], 0);
3231 }
3232 } else {
3233 return;
3234 }
3235 }
3236
3237 /**
3238 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5000
3239 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param error
3240 * @tc.desc : api test
3241 */
3242 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5000, TestSize.Level2)
3243 {
3244 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3245 if (cap) {
3246 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3247 ASSERT_NE(nullptr, capability);
3248 int32_t profile = HEVC_PROFILE_MAIN_10_HDR10_PLUS + 1;
3249 int32_t level = HEVC_LEVEL_62 + 1;
3250 ASSERT_NE(true, OH_AVCapability_AreProfileAndLevelSupported(capability, profile, level));
3251 } else {
3252 return;
3253 }
3254 }
3255
3256 /**
3257 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5100
3258 * @tc.name : OH_AVCapability_AreProfileAndLevelSupported param correct
3259 * @tc.desc : api test
3260 */
3261 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5100, TestSize.Level2)
3262 {
3263 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3264 if (cap) {
3265 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC,
3266 true, HARDWARE);
3267 ASSERT_NE(nullptr, capability);
3268 ASSERT_EQ(true, OH_AVCapability_AreProfileAndLevelSupported(capability, HEVC_PROFILE_MAIN, 1));
3269 } else {
3270 return;
3271 }
3272 }
3273
3274 /**
3275 * @tc.number : VIDEO_ENCODE_CAPABILITY_8700
3276 * @tc.name : AV_PIXEL_FORMAT_RGBA param correct
3277 * @tc.desc : api test
3278 */
3279 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8700, TestSize.Level2)
3280 {
3281 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
3282 if (cap) {
3283 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
3284 ASSERT_NE(nullptr, venc_);
3285 format = OH_AVFormat_Create();
3286 ASSERT_NE(nullptr, format);
3287 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3288 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3289 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3290 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3291 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
3292 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3293 } else {
3294 return;
3295 }
3296 }
3297
3298 /**
3299 * @tc.number : VIDEO_ENCODE_CAPABILITY_8800
3300 * @tc.name : AV_PIXEL_FORMAT_NV21 param correct
3301 * @tc.desc : api test
3302 */
3303 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8800, TestSize.Level2)
3304 {
3305 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
3306 if (cap) {
3307 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
3308 ASSERT_NE(nullptr, venc_);
3309 format = OH_AVFormat_Create();
3310 ASSERT_NE(nullptr, format);
3311 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3312 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3313 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3314 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3315 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
3316 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
3317 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3318 }else {
3319 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoEncoder_Configure(venc_, format));
3320 }
3321 } else {
3322 return;
3323 }
3324 }
3325
3326 /**
3327 * @tc.number : VIDEO_ENCODE_CAPABILITY_8900
3328 * @tc.name : OH_MD_KEY_BITRATE param correct
3329 * @tc.desc : api test
3330 */
3331 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_8900, TestSize.Level2)
3332 {
3333 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
3334 if (cap) {
3335 int64_t min = 1;
3336 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
3337 ASSERT_NE(nullptr, venc_);
3338 format = OH_AVFormat_Create();
3339 ASSERT_NE(nullptr, format);
3340 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3341 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3342 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3343 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, min);
3344 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
3345 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
3346 EXPECT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
3347 }else {
3348 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3349 }
3350 } else {
3351 return;
3352 }
3353 }
3354
3355 /**
3356 * @tc.number : VIDEO_ENCODE_CAPABILITY_9000
3357 * @tc.name : OH_MD_KEY_BITRATE param error
3358 * @tc.desc : api test
3359 */
3360 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_CAPABILITY_9000, TestSize.Level2)
3361 {
3362 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
3363 if (cap) {
3364 int64_t max = 100000001;
3365 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
3366 ASSERT_NE(nullptr, venc_);
3367 format = OH_AVFormat_Create();
3368 ASSERT_NE(nullptr, format);
3369 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3370 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3371 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3372 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, max);
3373 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
3374 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
3375 } else {
3376 return;
3377 }
3378 }
3379
3380 /**
3381 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5500
3382 * @tc.name : AV_PIXEL_FORMAT_NV21 param correct
3383 * @tc.desc : api test
3384 */
3385 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5500, TestSize.Level2)
3386 {
3387 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3388 if (cap) {
3389 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3390 ASSERT_NE(nullptr, venc_);
3391 format = OH_AVFormat_Create();
3392 ASSERT_NE(nullptr, format);
3393 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3394 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3395 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3396 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3397 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
3398 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
3399 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3400 }else {
3401 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoEncoder_Configure(venc_, format));
3402 }
3403 } else {
3404 return;
3405 }
3406 }
3407
3408 /**
3409 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5600
3410 * @tc.name : AV_PIXEL_FORMAT_YUVI420 param correct
3411 * @tc.desc : api test
3412 */
3413 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5600, TestSize.Level2)
3414 {
3415 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3416 if (cap) {
3417 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3418 ASSERT_NE(nullptr, venc_);
3419 format = OH_AVFormat_Create();
3420 ASSERT_NE(nullptr, format);
3421 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3422 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3423 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3424 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3425 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
3426 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3427 } else {
3428 return;
3429 }
3430 }
3431
3432 /**
3433 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5700
3434 * @tc.name : AV_PIXEL_FORMAT_RGBA param correct
3435 * @tc.desc : api test
3436 */
3437 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5700, TestSize.Level2)
3438 {
3439 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3440 if (cap) {
3441 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3442 ASSERT_NE(nullptr, venc_);
3443 format = OH_AVFormat_Create();
3444 ASSERT_NE(nullptr, format);
3445 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3446 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3447 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3448 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE);
3449 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
3450 EXPECT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3451 } else {
3452 return;
3453 }
3454 }
3455
3456 /**
3457 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5800
3458 * @tc.name : OH_MD_KEY_BITRATE param correct
3459 * @tc.desc : api test
3460 */
3461 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5800, TestSize.Level2)
3462 {
3463 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3464 if (cap) {
3465 int64_t min = 1;
3466 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3467 ASSERT_NE(nullptr, venc_);
3468 format = OH_AVFormat_Create();
3469 ASSERT_NE(nullptr, format);
3470 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3471 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3472 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3473 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, min);
3474 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
3475 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
3476 EXPECT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
3477 }else {
3478 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
3479 }
3480 } else {
3481 return;
3482 }
3483 }
3484
3485 /**
3486 * @tc.number : VIDEO_ENCODE_HEVC_CAPABILITY_5900
3487 * @tc.name : OH_MD_KEY_BITRATE param error
3488 * @tc.desc : api test
3489 */
3490 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_HEVC_CAPABILITY_5900, TestSize.Level2)
3491 {
3492 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
3493 if (cap) {
3494 int64_t max = 100000001;
3495 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
3496 ASSERT_NE(nullptr, venc_);
3497 format = OH_AVFormat_Create();
3498 ASSERT_NE(nullptr, format);
3499 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
3500 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
3501 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DEFAULT_FRAME_RATE);
3502 (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, max);
3503 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
3504 ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoEncoder_Configure(venc_, format));
3505 } else {
3506 return;
3507 }
3508 }
3509 } // namespace
3510