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