1 /*
2  * Copyright (C) 2024 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 #include <limits>
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videoenc_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 namespace {
25 OH_AVCodec *venc_ = NULL;
26 OH_AVCapability *cap = nullptr;
27 OH_AVCapability *cap_hevc = nullptr;
28 constexpr uint32_t CODEC_NAME_SIZE = 128;
29 constexpr uint32_t DEFAULT_BITRATE = 1000000;
30 char g_codecName[CODEC_NAME_SIZE] = {};
31 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
32 const char *INP_DIR_720 = "/data/test/media/1280_720_nv.yuv";
33 constexpr uint32_t DEFAULT_WIDTH = 1280;
34 constexpr uint32_t DEFAULT_HEIGHT = 720;
35 } // namespace
36 namespace OHOS {
37 namespace Media {
38 class HwEncSetParamNdkTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     void SetUp() override;
43     void TearDown() override;
44     void InputFunc();
45     void OutputFunc();
46     void Release();
47     int32_t Stop();
48 };
49 } // namespace Media
50 } // namespace OHOS
51 
52 using namespace std;
53 using namespace OHOS;
54 using namespace OHOS::Media;
55 using namespace testing::ext;
56 
SetUpTestCase()57 void HwEncSetParamNdkTest::SetUpTestCase()
58 {
59     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
60     const char *tmpCodecName = OH_AVCapability_GetName(cap);
61     if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
62         cout << "memcpy failed" << endl;
63     cout << "codecname: " << g_codecName << endl;
64     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
65     const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
66     if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
67         cout << "memcpy failed" << endl;
68     cout << "codecname_hevc: " << g_codecNameHEVC << endl;
69 }
TearDownTestCase()70 void HwEncSetParamNdkTest::TearDownTestCase() {}
SetUp()71 void HwEncSetParamNdkTest::SetUp() {}
TearDown()72 void HwEncSetParamNdkTest::TearDown()
73 {
74     if (venc_ != NULL) {
75         OH_VideoEncoder_Destroy(venc_);
76         venc_ = nullptr;
77     }
78 }
79 namespace {
80 /**
81  * @tc.number    : RESET_BITRATE_001
82  * @tc.name      : reset bitrate use illegal value
83  * @tc.desc      : function test
84  */
85 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_001, TestSize.Level1)
86 {
87     auto vEncSample = make_unique<VEncAPI11Sample>();
88     vEncSample->INP_DIR = INP_DIR_720;
89     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
90     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
91     vEncSample->DEFAULT_FRAME_RATE = 30;
92     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
93     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
94     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
95     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
96     OH_AVFormat *format = OH_AVFormat_Create();
97     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
98     EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
99     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, LONG_MAX);
100     EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
101     OH_AVFormat_Destroy(format);
102     vEncSample->WaitForEOS();
103     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
104 }
105 
106 /**
107  * @tc.number    : RESET_BITRATE_002
108  * @tc.name      : reset bitrate in CQ mode
109  * @tc.desc      : function test
110  */
111 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_002, TestSize.Level0)
112 {
113     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
114         auto vEncSample = make_unique<VEncAPI11Sample>();
115         vEncSample->INP_DIR = INP_DIR_720;
116         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
117         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
118         vEncSample->DEFAULT_FRAME_RATE = 30;
119         vEncSample->DEFAULT_BITRATE_MODE = CQ;
120         vEncSample->OUT_DIR = "/data/test/media/CQ_1s_.h264";
121         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
122         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
123         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
124         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
125         OH_AVFormat *format = OH_AVFormat_Create();
126         (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE >> 1);
127         EXPECT_NE(AV_ERR_OK, vEncSample->SetParameter(format));
128         OH_AVFormat_Destroy(format);
129         vEncSample->WaitForEOS();
130         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
131     }
132 }
133 
134 /**
135  * @tc.number    : RESET_BITRATE_003
136  * @tc.name      : reset bitrate in CBR mode ,gop size -1
137  * @tc.desc      : function test
138  */
139 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_003, TestSize.Level0)
140 {
141     auto vEncSample = make_unique<VEncAPI11Sample>();
142     vEncSample->INP_DIR = INP_DIR_720;
143     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
144     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
145     vEncSample->DEFAULT_FRAME_RATE = 30;
146     vEncSample->DEFAULT_BITRATE_MODE = CBR;
147     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
148     vEncSample->enableAutoSwitchParam = true;
149     vEncSample->needResetBitrate = true;
150     vEncSample->OUT_DIR = "/data/test/media/cbr_-1_.h264";
151     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
152     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
153     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
154     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
155     vEncSample->WaitForEOS();
156     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
157 }
158 
159 /**
160  * @tc.number    : RESET_BITRATE_004
161  * @tc.name      : reset bitrate in CBR mode ,gop size 0
162  * @tc.desc      : function test
163  */
164 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_004, TestSize.Level0)
165 {
166     auto vEncSample = make_unique<VEncAPI11Sample>();
167     vEncSample->INP_DIR = INP_DIR_720;
168     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
169     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
170     vEncSample->DEFAULT_FRAME_RATE = 30;
171     vEncSample->DEFAULT_BITRATE_MODE = CBR;
172     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
173     vEncSample->enableAutoSwitchParam = true;
174     vEncSample->needResetBitrate = true;
175     vEncSample->OUT_DIR = "/data/test/media/cbr_0_.h264";
176     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
177     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
178     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
179     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
180     vEncSample->WaitForEOS();
181     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
182 }
183 
184 /**
185  * @tc.number    : RESET_BITRATE_005
186  * @tc.name      : reset bitrate in CBR mode ,gop size 1s
187  * @tc.desc      : function test
188  */
189 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_005, TestSize.Level0)
190 {
191     auto vEncSample = make_unique<VEncAPI11Sample>();
192     vEncSample->INP_DIR = INP_DIR_720;
193     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
194     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
195     vEncSample->DEFAULT_FRAME_RATE = 30;
196     vEncSample->DEFAULT_BITRATE_MODE = CBR;
197     vEncSample->enableAutoSwitchParam = true;
198     vEncSample->needResetBitrate = true;
199     vEncSample->OUT_DIR = "/data/test/media/cbr_1s_.h264";
200     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
201     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
202     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
203     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
204     vEncSample->WaitForEOS();
205     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
206 }
207 
208 
209 /**
210  * @tc.number    : RESET_BITRATE_006
211  * @tc.name      : reset bitrate in VBR mode
212  * @tc.desc      : function test
213  */
214 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_006, TestSize.Level0)
215 {
216     auto vEncSample = make_unique<VEncAPI11Sample>();
217     vEncSample->INP_DIR = INP_DIR_720;
218     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
219     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
220     vEncSample->DEFAULT_FRAME_RATE = 30;
221     vEncSample->DEFAULT_BITRATE_MODE = VBR;
222     vEncSample->enableAutoSwitchParam = true;
223     vEncSample->needResetBitrate = true;
224     vEncSample->OUT_DIR = "/data/test/media/vbr_1s_.h264";
225     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
226     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
227     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
228     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
229     vEncSample->WaitForEOS();
230     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
231 }
232 
233 /**
234  * @tc.number    : RESET_BITRATE_007
235  * @tc.name      : reset bitrate use illegal value, h265
236  * @tc.desc      : function test
237  */
238 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_007, TestSize.Level1)
239 {
240     auto vEncSample = make_unique<VEncAPI11Sample>();
241     vEncSample->INP_DIR = INP_DIR_720;
242     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
243     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
244     vEncSample->DEFAULT_FRAME_RATE = 30;
245     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
246     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
247     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
248     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
249     OH_AVFormat *format = OH_AVFormat_Create();
250     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, -1);
251     EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
252     (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, LONG_MAX);
253     EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
254     OH_AVFormat_Destroy(format);
255     vEncSample->WaitForEOS();
256     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
257 }
258 
259 /**
260  * @tc.number    : RESET_BITRATE_008
261  * @tc.name      : reset bitrate in CQ mode, h265
262  * @tc.desc      : function test
263  */
264 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_008, TestSize.Level0)
265 {
266     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
267         auto vEncSample = make_unique<VEncAPI11Sample>();
268         vEncSample->INP_DIR = INP_DIR_720;
269         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
270         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
271         vEncSample->DEFAULT_FRAME_RATE = 30;
272         vEncSample->DEFAULT_BITRATE_MODE = CQ;
273         vEncSample->OUT_DIR = "/data/test/media/CQ_1s_.h265";
274         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
275         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
276         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
277         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
278         OH_AVFormat *format = OH_AVFormat_Create();
279         (void)OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, DEFAULT_BITRATE >> 1);
280         EXPECT_NE(AV_ERR_OK, vEncSample->SetParameter(format));
281         OH_AVFormat_Destroy(format);
282         vEncSample->WaitForEOS();
283         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
284     }
285 }
286 
287 /**
288  * @tc.number    : RESET_BITRATE_009
289  * @tc.name      : reset bitrate in CBR mode ,gop size -1, h265
290  * @tc.desc      : function test
291  */
292 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_009, TestSize.Level0)
293 {
294     auto vEncSample = make_unique<VEncAPI11Sample>();
295     vEncSample->INP_DIR = INP_DIR_720;
296     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
297     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
298     vEncSample->DEFAULT_FRAME_RATE = 30;
299     vEncSample->DEFAULT_BITRATE_MODE = CBR;
300     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
301     vEncSample->enableAutoSwitchParam = true;
302     vEncSample->needResetBitrate = true;
303     vEncSample->OUT_DIR = "/data/test/media/cbr_-1_.h264";
304     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
305     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
306     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
307     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
308     vEncSample->WaitForEOS();
309     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
310 }
311 
312 /**
313  * @tc.number    : RESET_BITRATE_010
314  * @tc.name      : reset bitrate in CBR mode ,gop size 0, h265
315  * @tc.desc      : function test
316  */
317 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_010, TestSize.Level0)
318 {
319     auto vEncSample = make_unique<VEncAPI11Sample>();
320     vEncSample->INP_DIR = INP_DIR_720;
321     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
322     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
323     vEncSample->DEFAULT_FRAME_RATE = 30;
324     vEncSample->DEFAULT_BITRATE_MODE = CBR;
325     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
326     vEncSample->enableAutoSwitchParam = true;
327     vEncSample->needResetBitrate = true;
328     vEncSample->OUT_DIR = "/data/test/media/cbr_0_.h264";
329     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
330     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
331     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
332     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
333     vEncSample->WaitForEOS();
334     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
335 }
336 
337 /**
338  * @tc.number    : RESET_BITRATE_011
339  * @tc.name      : reset bitrate in CBR mode ,gop size 1s, h265
340  * @tc.desc      : function test
341  */
342 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_011, TestSize.Level0)
343 {
344     auto vEncSample = make_unique<VEncAPI11Sample>();
345     vEncSample->INP_DIR = INP_DIR_720;
346     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
347     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
348     vEncSample->DEFAULT_FRAME_RATE = 30;
349     vEncSample->DEFAULT_BITRATE_MODE = CBR;
350     vEncSample->enableAutoSwitchParam = true;
351     vEncSample->needResetBitrate = true;
352     vEncSample->OUT_DIR = "/data/test/media/cbr_1s_.h264";
353     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
354     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
355     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
356     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
357     vEncSample->WaitForEOS();
358     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
359 }
360 
361 /**
362  * @tc.number    : RESET_BITRATE_012
363  * @tc.name      : reset bitrate in vbr mode h265
364  * @tc.desc      : function test
365  */
366 HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_012, TestSize.Level0)
367 {
368     auto vEncSample = make_unique<VEncAPI11Sample>();
369     vEncSample->INP_DIR = INP_DIR_720;
370     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
371     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
372     vEncSample->DEFAULT_FRAME_RATE = 30;
373     vEncSample->DEFAULT_BITRATE_MODE = VBR;
374     vEncSample->enableAutoSwitchParam = true;
375     vEncSample->needResetBitrate = true;
376     vEncSample->OUT_DIR = "/data/test/media/vbr_1s_.h264";
377     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
378     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
379     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
380     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
381     vEncSample->WaitForEOS();
382     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
383 }
384 
385 /**
386  * @tc.number    : RESET_FRAMERATE_001
387  * @tc.name      : reset framerate use illegal value
388  * @tc.desc      : function test
389  */
390 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_001, TestSize.Level0)
391 {
392     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
393         auto vEncSample = make_unique<VEncAPI11Sample>();
394         vEncSample->INP_DIR = INP_DIR_720;
395         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
396         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
397         vEncSample->DEFAULT_FRAME_RATE = 30;
398         vEncSample->DEFAULT_BITRATE_MODE = CQ;
399         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
400         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
401         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
402         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
403         OH_AVFormat *format = OH_AVFormat_Create();
404         (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, -1.0);
405         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
406         OH_AVFormat_Destroy(format);
407         vEncSample->WaitForEOS();
408         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
409     }
410 }
411 /**
412  * @tc.number    : RESET_FRAMERATE_012
413  * @tc.name      : reset framerate use illegal value
414  * @tc.desc      : function test
415  */
416 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_012, TestSize.Level0)
417 {
418     if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
419         auto vEncSample = make_unique<VEncAPI11Sample>();
420         vEncSample->INP_DIR = INP_DIR_720;
421         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
422         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
423         vEncSample->DEFAULT_FRAME_RATE = 30;
424         vEncSample->DEFAULT_BITRATE_MODE = CQ;
425         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
426         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
427         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
428         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
429         OH_AVFormat *format = OH_AVFormat_Create();
430         (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, -1.0);
431         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
432         OH_AVFormat_Destroy(format);
433         vEncSample->WaitForEOS();
434         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
435     }
436 }
437 /**
438  * @tc.number    : RESET_FRAMERATE_013
439  * @tc.name      : reset framerate use max value
440  * @tc.desc      : function test
441  */
442 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_013, TestSize.Level0)
443 {
444     if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
445         auto vEncSample = make_unique<VEncAPI11Sample>();
446         vEncSample->INP_DIR = INP_DIR_720;
447         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
448         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
449         vEncSample->DEFAULT_FRAME_RATE = 30;
450         vEncSample->DEFAULT_BITRATE_MODE = CQ;
451         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
452         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
453         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
454         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
455         OH_AVFormat *format = OH_AVFormat_Create();
456         (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DBL_MAX);
457         EXPECT_EQ(AV_ERR_OK, vEncSample->SetParameter(format));
458         OH_AVFormat_Destroy(format);
459         vEncSample->WaitForEOS();
460         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
461     }
462 }
463 /**
464  * @tc.number    : RESET_FRAMERATE_014
465  * @tc.name      : reset framerate use max value
466  * @tc.desc      : function test
467  */
468 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_014, TestSize.Level0)
469 {
470     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
471         auto vEncSample = make_unique<VEncAPI11Sample>();
472         vEncSample->INP_DIR = INP_DIR_720;
473         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
474         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
475         vEncSample->DEFAULT_FRAME_RATE = 30;
476         vEncSample->DEFAULT_BITRATE_MODE = CQ;
477         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
478         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
479         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
480         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
481         OH_AVFormat *format = OH_AVFormat_Create();
482         (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DBL_MAX);
483         EXPECT_EQ(AV_ERR_OK, vEncSample->SetParameter(format));
484         OH_AVFormat_Destroy(format);
485         vEncSample->WaitForEOS();
486         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
487     }
488 }
489 /**
490  * @tc.number    : RESET_FRAMERATE_002
491  * @tc.name      : reset framerate in CQ mode
492  * @tc.desc      : function test
493  */
494 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_002, TestSize.Level1)
495 {
496     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
497         auto vEncSample = make_unique<VEncAPI11Sample>();
498         vEncSample->INP_DIR = INP_DIR_720;
499         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
500         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
501         vEncSample->DEFAULT_FRAME_RATE = 30;
502         vEncSample->enableAutoSwitchParam = true;
503         vEncSample->needResetFrameRate = true;
504         vEncSample->DEFAULT_BITRATE_MODE = CQ;
505         vEncSample->OUT_DIR = "/data/test/media/CQ_1s_r_.h264";
506         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
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 /**
516  * @tc.number    : RESET_FRAMERATE_003
517  * @tc.name      : reset framerate in CBR mode, gop size -1
518  * @tc.desc      : function test
519  */
520 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_003, TestSize.Level1)
521 {
522     auto vEncSample = make_unique<VEncAPI11Sample>();
523     vEncSample->INP_DIR = INP_DIR_720;
524     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
525     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
526     vEncSample->DEFAULT_FRAME_RATE = 30;
527     vEncSample->enableAutoSwitchParam = true;
528     vEncSample->needResetFrameRate = true;
529     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
530     vEncSample->DEFAULT_BITRATE_MODE = CBR;
531     vEncSample->OUT_DIR = "/data/test/media/cbr_-1_r_.h264";
532     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
533     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
534     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
535     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
536     vEncSample->WaitForEOS();
537     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
538 }
539 
540 /**
541  * @tc.number    : RESET_FRAMERATE_004
542  * @tc.name      : reset framerate in CBR mode, gop size 0
543  * @tc.desc      : function test
544  */
545 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_004, TestSize.Level1)
546 {
547     auto vEncSample = make_unique<VEncAPI11Sample>();
548     vEncSample->INP_DIR = INP_DIR_720;
549     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
550     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
551     vEncSample->DEFAULT_FRAME_RATE = 30;
552     vEncSample->enableAutoSwitchParam = true;
553     vEncSample->needResetFrameRate = true;
554     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
555     vEncSample->DEFAULT_BITRATE_MODE = CBR;
556     vEncSample->OUT_DIR = "/data/test/media/cbr_0_r_.h264";
557     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
558     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
559     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
560     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
561     vEncSample->WaitForEOS();
562     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
563 }
564 
565 /**
566  * @tc.number    : RESET_FRAMERATE_005
567  * @tc.name      : reset framerate in CBR mode, gop size 1s
568  * @tc.desc      : function test
569  */
570 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_005, TestSize.Level1)
571 {
572     auto vEncSample = make_unique<VEncAPI11Sample>();
573     vEncSample->INP_DIR = INP_DIR_720;
574     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
575     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
576     vEncSample->DEFAULT_FRAME_RATE = 30;
577     vEncSample->enableAutoSwitchParam = true;
578     vEncSample->needResetFrameRate = true;
579     vEncSample->DEFAULT_BITRATE_MODE = CBR;
580     vEncSample->OUT_DIR = "/data/test/media/cbr_1s_r_.h264";
581     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
582     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
583     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
584     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
585     vEncSample->WaitForEOS();
586     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
587 }
588 
589 /**
590  * @tc.number    : RESET_FRAMERATE_006
591  * @tc.name      : reset framerate in VBR mode, gop size 1s
592  * @tc.desc      : function test
593  */
594 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_006, TestSize.Level1)
595 {
596     auto vEncSample = make_unique<VEncAPI11Sample>();
597     vEncSample->INP_DIR = INP_DIR_720;
598     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
599     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
600     vEncSample->DEFAULT_FRAME_RATE = 30;
601     vEncSample->enableAutoSwitchParam = true;
602     vEncSample->needResetFrameRate = true;
603     vEncSample->DEFAULT_BITRATE_MODE = VBR;
604     vEncSample->OUT_DIR = "/data/test/media/vbr_1s_r_.h264";
605     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
606     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
607     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
608     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
609     vEncSample->WaitForEOS();
610     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
611 }
612 
613 
614 /**
615  * @tc.number    : RESET_FRAMERATE_007
616  * @tc.name      : reset framerate in CQ mode hevc
617  * @tc.desc      : function test
618  */
619 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_007, TestSize.Level1)
620 {
621     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
622         auto vEncSample = make_unique<VEncAPI11Sample>();
623         vEncSample->INP_DIR = INP_DIR_720;
624         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
625         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
626         vEncSample->DEFAULT_FRAME_RATE = 30;
627         vEncSample->enableAutoSwitchParam = true;
628         vEncSample->needResetFrameRate = true;
629         vEncSample->DEFAULT_BITRATE_MODE = CQ;
630         vEncSample->OUT_DIR = "/data/test/media/CQ_1s_r_.h265";
631         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
632         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
633         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
634         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
635         vEncSample->WaitForEOS();
636         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
637     }
638 }
639 
640 /**
641  * @tc.number    : RESET_FRAMERATE_008
642  * @tc.name      : reset framerate in CBR mode, gop size -1 hevc
643  * @tc.desc      : function test
644  */
645 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_008, TestSize.Level1)
646 {
647     auto vEncSample = make_unique<VEncAPI11Sample>();
648     vEncSample->INP_DIR = INP_DIR_720;
649     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
650     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
651     vEncSample->DEFAULT_FRAME_RATE = 30;
652     vEncSample->enableAutoSwitchParam = true;
653     vEncSample->needResetFrameRate = true;
654     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
655     vEncSample->DEFAULT_BITRATE_MODE = CBR;
656     vEncSample->OUT_DIR = "/data/test/media/cbr_-1_r_.h265";
657     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
658     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
659     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
660     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
661     vEncSample->WaitForEOS();
662     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
663 }
664 
665 /**
666  * @tc.number    : RESET_FRAMERATE_009
667  * @tc.name      : reset framerate in CBR mode, gop size 0 hevc
668  * @tc.desc      : function test
669  */
670 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_009, TestSize.Level1)
671 {
672     auto vEncSample = make_unique<VEncAPI11Sample>();
673     vEncSample->INP_DIR = INP_DIR_720;
674     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
675     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
676     vEncSample->DEFAULT_FRAME_RATE = 30;
677     vEncSample->enableAutoSwitchParam = true;
678     vEncSample->needResetFrameRate = true;
679     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
680     vEncSample->DEFAULT_BITRATE_MODE = CBR;
681     vEncSample->OUT_DIR = "/data/test/media/cbr_0_r_.h265";
682     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
683     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
684     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
685     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
686     vEncSample->WaitForEOS();
687     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
688 }
689 
690 /**
691  * @tc.number    : RESET_FRAMERATE_010
692  * @tc.name      : reset framerate in CBR mode, gop size 1s hevc
693  * @tc.desc      : function test
694  */
695 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_010, TestSize.Level1)
696 {
697     auto vEncSample = make_unique<VEncAPI11Sample>();
698     vEncSample->INP_DIR = INP_DIR_720;
699     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
700     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
701     vEncSample->DEFAULT_FRAME_RATE = 30;
702     vEncSample->enableAutoSwitchParam = true;
703     vEncSample->needResetFrameRate = true;
704     vEncSample->DEFAULT_BITRATE_MODE = CBR;
705     vEncSample->OUT_DIR = "/data/test/media/cbr_1s_r_.h265";
706     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
707     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
708     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
709     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
710     vEncSample->WaitForEOS();
711     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
712 }
713 
714 /**
715  * @tc.number    : RESET_FRAMERATE_011
716  * @tc.name      : reset framerate in VBR mode, gop size 1s hevc
717  * @tc.desc      : function test
718  */
719 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_011, TestSize.Level1)
720 {
721     auto vEncSample = make_unique<VEncAPI11Sample>();
722     vEncSample->INP_DIR = INP_DIR_720;
723     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
724     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
725     vEncSample->DEFAULT_FRAME_RATE = 30;
726     vEncSample->enableAutoSwitchParam = true;
727     vEncSample->needResetFrameRate = true;
728     vEncSample->DEFAULT_BITRATE_MODE = VBR;
729     vEncSample->OUT_DIR = "/data/test/media/vbr_1s_r_.h265";
730     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
731     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
732     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
733     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
734     vEncSample->WaitForEOS();
735     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
736 }
737 
738 /**
739  * @tc.number    : RESET_QP_001
740  * @tc.name      : reset QP with illegal parameter
741  * @tc.desc      : function test
742  */
743 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_001, TestSize.Level1)
744 {
745     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
746         auto vEncSample = make_unique<VEncAPI11Sample>();
747         vEncSample->INP_DIR = INP_DIR_720;
748         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
749         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
750         vEncSample->DEFAULT_FRAME_RATE = 30;
751         vEncSample->DEFAULT_BITRATE_MODE = CQ;
752         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
753         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
754         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
755         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
756         OH_AVFormat *format = OH_AVFormat_Create();
757         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, -1);
758         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, -1);
759         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
760         OH_AVFormat_Destroy(format);
761         format = OH_AVFormat_Create();
762         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, 200);
763         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, 200);
764         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
765         OH_AVFormat_Destroy(format);
766         vEncSample->WaitForEOS();
767         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
768     }
769 }
770 /**
771  * @tc.number    : RESET_QP_002
772  * @tc.name      : reset QP with illegal parameter
773  * @tc.desc      : function test
774  */
775 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_002, TestSize.Level1)
776 {
777     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
778         auto vEncSample = make_unique<VEncAPI11Sample>();
779         vEncSample->INP_DIR = INP_DIR_720;
780         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
781         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
782         vEncSample->DEFAULT_FRAME_RATE = 30;
783         vEncSample->DEFAULT_BITRATE_MODE = CQ;
784         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
785         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
786         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
787         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
788         OH_AVFormat *format = OH_AVFormat_Create();
789         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, -1);
790         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, -1);
791         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
792         OH_AVFormat_Destroy(format);
793         format = OH_AVFormat_Create();
794         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, 200);
795         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, 200);
796         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
797         OH_AVFormat_Destroy(format);
798         vEncSample->WaitForEOS();
799         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
800     }
801 }
802 
803 /**
804  * @tc.number    : RESET_QP_003
805  * @tc.name      : reset QP in cq mode, use buffer->setparameter
806  * @tc.desc      : function test
807  */
808 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_003, TestSize.Level1)
809 {
810     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
811         auto vEncSample = make_unique<VEncAPI11Sample>();
812         vEncSample->INP_DIR = INP_DIR_720;
813         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
814         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
815         vEncSample->DEFAULT_FRAME_RATE = 10;
816         vEncSample->DEFAULT_BITRATE_MODE = CQ;
817         vEncSample->enableAutoSwitchBufferParam = true;
818         vEncSample->needResetQP = true;
819         vEncSample->switchParamsTimeSec = 1;
820         vEncSample->OUT_DIR = "/data/test/media/cq_qp_b_.h264";
821         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
822         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
823         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
824         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
825         vEncSample->WaitForEOS();
826         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
827     }
828 }
829 
830 /**
831  * @tc.number    : RESET_QP_004
832  * @tc.name      : reset QP in CQ mode, use setparameter
833  * @tc.desc      : function test
834  */
835 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_004, TestSize.Level1)
836 {
837     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
838         auto vEncSample = make_unique<VEncAPI11Sample>();
839         vEncSample->INP_DIR = INP_DIR_720;
840         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
841         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
842         vEncSample->DEFAULT_FRAME_RATE = 10;
843         vEncSample->DEFAULT_BITRATE_MODE = CQ;
844         vEncSample->enableAutoSwitchParam = true;
845         vEncSample->needResetQP = true;
846         vEncSample->switchParamsTimeSec = 1;
847         vEncSample->OUT_DIR = "/data/test/media/cq_qp_.h264";
848         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
849         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
850         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
851         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
852         vEncSample->WaitForEOS();
853         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
854     }
855 }
856 
857 /**
858  * @tc.number    : RESET_QP_005
859  * @tc.name      : reset QP in CBR mode, use buffer->setparameter
860  * @tc.desc      : function test
861  */
862 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_005, TestSize.Level1)
863 {
864     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
865         auto vEncSample = make_unique<VEncAPI11Sample>();
866         vEncSample->INP_DIR = INP_DIR_720;
867         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
868         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
869         vEncSample->DEFAULT_FRAME_RATE = 10;
870         vEncSample->DEFAULT_BITRATE_MODE = CBR;
871         vEncSample->enableAutoSwitchBufferParam = true;
872         vEncSample->needResetQP = true;
873         vEncSample->switchParamsTimeSec = 1;
874         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_b_.h264";
875         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
876         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
877         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
878         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
879         vEncSample->WaitForEOS();
880         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
881     }
882 }
883 
884 /**
885  * @tc.number    : RESET_QP_006
886  * @tc.name      : reset QP in CBR mode, use setparameter
887  * @tc.desc      : function test
888  */
889 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_006, TestSize.Level1)
890 {
891     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
892         auto vEncSample = make_unique<VEncAPI11Sample>();
893         vEncSample->INP_DIR = INP_DIR_720;
894         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
895         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
896         vEncSample->DEFAULT_FRAME_RATE = 10;
897         vEncSample->DEFAULT_BITRATE_MODE = CBR;
898         vEncSample->enableAutoSwitchParam = true;
899         vEncSample->needResetQP = true;
900         vEncSample->switchParamsTimeSec = 1;
901         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_.h264";
902         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
903         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
904         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
905         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
906         vEncSample->WaitForEOS();
907         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
908     }
909 }
910 
911 /**
912  * @tc.number    : RESET_QP_007
913  * @tc.name      : reset QP in VBR mode, use buffer->setparameter
914  * @tc.desc      : function test
915  */
916 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_007, TestSize.Level1)
917 {
918     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
919         auto vEncSample = make_unique<VEncAPI11Sample>();
920         vEncSample->INP_DIR = INP_DIR_720;
921         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
922         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
923         vEncSample->DEFAULT_FRAME_RATE = 10;
924         vEncSample->DEFAULT_BITRATE_MODE = VBR;
925         vEncSample->enableAutoSwitchBufferParam = true;
926         vEncSample->needResetQP = true;
927         vEncSample->switchParamsTimeSec = 1;
928         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_b_.h264";
929         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
930         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
931         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
932         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
933         vEncSample->WaitForEOS();
934         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
935     }
936 }
937 
938 /**
939  * @tc.number    : RESET_QP_008
940  * @tc.name      : reset QP in VBR mode, use setparameter
941  * @tc.desc      : function test
942  */
943 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_008, TestSize.Level1)
944 {
945     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
946         auto vEncSample = make_unique<VEncAPI11Sample>();
947         vEncSample->INP_DIR = INP_DIR_720;
948         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
949         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
950         vEncSample->DEFAULT_FRAME_RATE = 10;
951         vEncSample->DEFAULT_BITRATE_MODE = VBR;
952         vEncSample->enableAutoSwitchParam = true;
953         vEncSample->needResetQP = true;
954         vEncSample->switchParamsTimeSec = 1;
955         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_.h264";
956         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
957         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
958         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
959         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
960         vEncSample->WaitForEOS();
961         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
962     }
963 }
964 
965 /**
966  * @tc.number    : RESET_QP_009
967  * @tc.name      : reset QP in cq mode, use buffer->setparameter H265
968  * @tc.desc      : function test
969  */
970 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_009, TestSize.Level1)
971 {
972     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
973         auto vEncSample = make_unique<VEncAPI11Sample>();
974         vEncSample->INP_DIR = INP_DIR_720;
975         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
976         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
977         vEncSample->DEFAULT_FRAME_RATE = 10;
978         vEncSample->DEFAULT_BITRATE_MODE = CQ;
979         vEncSample->enableAutoSwitchBufferParam = true;
980         vEncSample->needResetQP = true;
981         vEncSample->switchParamsTimeSec = 1;
982         vEncSample->OUT_DIR = "/data/test/media/cq_qp_b_.h265";
983         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
984         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
985         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
986         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
987         vEncSample->WaitForEOS();
988         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
989     }
990 }
991 
992 /**
993  * @tc.number    : RESET_QP_010
994  * @tc.name      : reset QP in CQ mode, use setparameter H265
995  * @tc.desc      : function test
996  */
997 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_010, TestSize.Level1)
998 {
999     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1000         auto vEncSample = make_unique<VEncAPI11Sample>();
1001         vEncSample->INP_DIR = INP_DIR_720;
1002         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1003         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1004         vEncSample->DEFAULT_FRAME_RATE = 10;
1005         vEncSample->DEFAULT_BITRATE_MODE = CQ;
1006         vEncSample->enableAutoSwitchParam = true;
1007         vEncSample->needResetQP = true;
1008         vEncSample->switchParamsTimeSec = 1;
1009         vEncSample->OUT_DIR = "/data/test/media/cq_qp_.h265";
1010         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1011         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1012         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1013         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1014         vEncSample->WaitForEOS();
1015         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1016     }
1017 }
1018 
1019 /**
1020  * @tc.number    : RESET_QP_011
1021  * @tc.name      : reset QP in CBR mode, use buffer->setparameter h265
1022  * @tc.desc      : function test
1023  */
1024 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_011, TestSize.Level1)
1025 {
1026     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1027         auto vEncSample = make_unique<VEncAPI11Sample>();
1028         vEncSample->INP_DIR = INP_DIR_720;
1029         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1030         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1031         vEncSample->DEFAULT_FRAME_RATE = 10;
1032         vEncSample->DEFAULT_BITRATE_MODE = CBR;
1033         vEncSample->enableAutoSwitchBufferParam = true;
1034         vEncSample->needResetQP = true;
1035         vEncSample->switchParamsTimeSec = 1;
1036         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_b_.h265";
1037         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1038         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1039         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1040         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1041         vEncSample->WaitForEOS();
1042         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1043     }
1044 }
1045 
1046 /**
1047  * @tc.number    : RESET_QP_012
1048  * @tc.name      : reset QP in CBR mode, use setparameter h265
1049  * @tc.desc      : function test
1050  */
1051 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_012, TestSize.Level1)
1052 {
1053     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1054         auto vEncSample = make_unique<VEncAPI11Sample>();
1055         vEncSample->INP_DIR = INP_DIR_720;
1056         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1057         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1058         vEncSample->DEFAULT_FRAME_RATE = 10;
1059         vEncSample->DEFAULT_BITRATE_MODE = CBR;
1060         vEncSample->enableAutoSwitchParam = true;
1061         vEncSample->needResetQP = true;
1062         vEncSample->switchParamsTimeSec = 1;
1063         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_.h265";
1064         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1065         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1066         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1067         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1068         vEncSample->WaitForEOS();
1069         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1070     }
1071 }
1072 
1073 /**
1074  * @tc.number    : RESET_QP_013
1075  * @tc.name      : reset QP in VBR mode, use buffer->setparameter h265
1076  * @tc.desc      : function test
1077  */
1078 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_013, TestSize.Level1)
1079 {
1080     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1081         auto vEncSample = make_unique<VEncAPI11Sample>();
1082         vEncSample->INP_DIR = INP_DIR_720;
1083         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1084         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1085         vEncSample->DEFAULT_FRAME_RATE = 10;
1086         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1087         vEncSample->enableAutoSwitchBufferParam = true;
1088         vEncSample->needResetQP = true;
1089         vEncSample->switchParamsTimeSec = 1;
1090         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_b_.h265";
1091         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1092         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1093         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1094         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1095         vEncSample->WaitForEOS();
1096         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1097     }
1098 }
1099 
1100 /**
1101  * @tc.number    : RESET_QP_014
1102  * @tc.name      : reset QP in VBR mode, use setparameter h265
1103  * @tc.desc      : function test
1104  */
1105 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_014, TestSize.Level1)
1106 {
1107     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1108         auto vEncSample = make_unique<VEncAPI11Sample>();
1109         vEncSample->INP_DIR = INP_DIR_720;
1110         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1111         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1112         vEncSample->DEFAULT_FRAME_RATE = 10;
1113         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1114         vEncSample->enableAutoSwitchParam = true;
1115         vEncSample->needResetQP = true;
1116         vEncSample->switchParamsTimeSec = 1;
1117         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_.h265";
1118         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1119         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1120         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1121         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1122         vEncSample->WaitForEOS();
1123         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1124     }
1125 }
1126 
1127 /**
1128  * @tc.number    : SET_PROFILE_001
1129  * @tc.name      : set profile main
1130  * @tc.desc      : function test
1131  */
1132 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_001, TestSize.Level1)
1133 {
1134     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1135         auto vEncSample = make_unique<VEncAPI11Sample>();
1136         vEncSample->INP_DIR = INP_DIR_720;
1137         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1138         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1139         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1140         vEncSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN;
1141         vEncSample->OUT_DIR = "/data/test/media/pq_vivid.h265";
1142         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1143         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1144         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1145         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1146         vEncSample->WaitForEOS();
1147         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1148     }
1149 }
1150 /**
1151  * @tc.number    : SET_PROFILE_002
1152  * @tc.name      : set profile main10
1153  * @tc.desc      : function test
1154  */
1155 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_002, TestSize.Level1)
1156 {
1157     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1158         auto vEncSample = make_unique<VEncAPI11Sample>();
1159         vEncSample->INP_DIR = INP_DIR_720;
1160         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1161         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1162         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1163         vEncSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN_10;
1164         vEncSample->OUT_DIR = "/data/test/media/pq_vivid.h265";
1165         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1166         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1167         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1168         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1169         vEncSample->WaitForEOS();
1170         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1171     }
1172 }
1173 /**
1174  * @tc.number    : SET_PROFILE_003
1175  * @tc.name      : set profile high
1176  * @tc.desc      : function test
1177  */
1178 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_003, TestSize.Level1)
1179 {
1180     if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1181         auto vEncSample = make_unique<VEncAPI11Sample>();
1182         vEncSample->INP_DIR = INP_DIR_720;
1183         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1184         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1185         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1186         vEncSample->DEFAULT_PROFILE = AVC_PROFILE_HIGH;
1187         vEncSample->OUT_DIR = "/data/test/media/1280_720_30_10Mb.h264";
1188         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1189         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1190         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1191         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1192         vEncSample->WaitForEOS();
1193         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1194     }
1195 }
1196 /**
1197  * @tc.number    : SET_PROFILE_004
1198  * @tc.name      : set profile main
1199  * @tc.desc      : function test
1200  */
1201 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_004, TestSize.Level1)
1202 {
1203     if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1204         auto vEncSample = make_unique<VEncAPI11Sample>();
1205         vEncSample->INP_DIR = INP_DIR_720;
1206         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1207         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1208         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1209         vEncSample->DEFAULT_PROFILE = AVC_PROFILE_MAIN;
1210         vEncSample->OUT_DIR = "/data/test/media/1280_720_30_10Mb.h264";
1211         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1212         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1213         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1214         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1215         vEncSample->WaitForEOS();
1216         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1217     }
1218 }
1219 /**
1220  * @tc.number    : SET_PROFILE_005
1221  * @tc.name      : set profile main
1222  * @tc.desc      : function test
1223  */
1224 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_005, TestSize.Level1)
1225 {
1226     if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1227         auto vEncSample = make_unique<VEncAPI11Sample>();
1228         vEncSample->INP_DIR = INP_DIR_720;
1229         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1230         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1231         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1232         vEncSample->DEFAULT_PROFILE = AVC_PROFILE_BASELINE;
1233         vEncSample->OUT_DIR = "/data/test/media/1280_720_30_10Mb.h264";
1234         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1235         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1236         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1237         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1238         vEncSample->WaitForEOS();
1239         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1240     }
1241 }
1242 /**
1243  * @tc.number    : SET_RANGE_FLAG_001
1244  * @tc.name      : set range flag true HEVC
1245  * @tc.desc      : function test
1246  */
1247 HWTEST_F(HwEncSetParamNdkTest, SET_RANGE_FLAG_001, TestSize.Level1)
1248 {
1249     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1250         auto vEncSample = make_unique<VEncAPI11Sample>();
1251         vEncSample->INP_DIR = INP_DIR_720;
1252         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1253         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1254         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1255         vEncSample->DEFAULT_RANGE_FLAG = 1;
1256         vEncSample->OUT_DIR = "/data/test/media/vbr_fullrange.h265";
1257         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1258         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1259         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1260         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1261         vEncSample->WaitForEOS();
1262         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1263     }
1264 }
1265 
1266 /**
1267  * @tc.number    : SET_RANGE_FLAG_002
1268  * @tc.name      : set range flag true
1269  * @tc.desc      : function test
1270  */
1271 HWTEST_F(HwEncSetParamNdkTest, SET_RANGE_FLAG_002, TestSize.Level1)
1272 {
1273     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1274         auto vEncSample = make_unique<VEncAPI11Sample>();
1275         vEncSample->INP_DIR = INP_DIR_720;
1276         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1277         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1278         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1279         vEncSample->DEFAULT_RANGE_FLAG = 1;
1280         vEncSample->OUT_DIR = "/data/test/media/vbr_fullrange.h264";
1281         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1282         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1283         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1284         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1285         vEncSample->WaitForEOS();
1286         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1287     }
1288 }
1289 
1290 /**
1291  * @tc.number    : SET_COLORSPACE_001
1292  * @tc.name      : set color space parameter
1293  * @tc.desc      : function test
1294  */
1295 HWTEST_F(HwEncSetParamNdkTest, SET_COLORSPACE_001, TestSize.Level1)
1296 {
1297     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1298         auto vEncSample = make_unique<VEncAPI11Sample>();
1299         vEncSample->INP_DIR = INP_DIR_720;
1300         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1301         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1302         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1303         vEncSample->DEFAULT_RANGE_FLAG = 1;
1304         vEncSample->enableColorSpaceParams = true;
1305         vEncSample->OUT_DIR = "/data/test/media/vbr_cs.h264";
1306         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1307         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1308         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1309         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1310         vEncSample->WaitForEOS();
1311         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1312     }
1313 }
1314 
1315 /**
1316  * @tc.number    : SET_COLORSPACE_002
1317  * @tc.name      : set color space parameter HEVC
1318  * @tc.desc      : function test
1319  */
1320 HWTEST_F(HwEncSetParamNdkTest, SET_COLORSPACE_002, TestSize.Level1)
1321 {
1322     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1323         auto vEncSample = make_unique<VEncAPI11Sample>();
1324         vEncSample->INP_DIR = INP_DIR_720;
1325         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1326         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1327         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1328         vEncSample->DEFAULT_RANGE_FLAG = 1;
1329         vEncSample->enableColorSpaceParams = true;
1330         vEncSample->OUT_DIR = "/data/test/media/vbr_cs.h265";
1331         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1332         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1333         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1334         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1335         vEncSample->WaitForEOS();
1336         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1337     }
1338 }
1339 
1340 /**
1341  * @tc.number    : SET_FORCE_IDR_001
1342  * @tc.name      : request i frame HEVC
1343  * @tc.desc      : function test
1344  */
1345 HWTEST_F(HwEncSetParamNdkTest, SET_FORCE_IDR_001, TestSize.Level1)
1346 {
1347     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1348         auto vEncSample = make_unique<VEncAPI11Sample>();
1349         vEncSample->INP_DIR = INP_DIR_720;
1350         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1351         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1352         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1353         vEncSample->DEFAULT_RANGE_FLAG = 1;
1354         vEncSample->enableForceIDR = true;
1355         vEncSample->OUT_DIR = "/data/test/media/vbr_i.h265";
1356         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1357         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1358         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1359         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1360         vEncSample->WaitForEOS();
1361         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1362     }
1363 }
1364 
1365 /**
1366  * @tc.number    : SET_FORCE_IDR_002
1367  * @tc.name      : request i frame
1368  * @tc.desc      : function test
1369  */
1370 HWTEST_F(HwEncSetParamNdkTest, SET_FORCE_IDR_002, TestSize.Level1)
1371 {
1372     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1373         auto vEncSample = make_unique<VEncAPI11Sample>();
1374         vEncSample->INP_DIR = INP_DIR_720;
1375         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1376         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1377         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1378         vEncSample->DEFAULT_RANGE_FLAG = 1;
1379         vEncSample->enableForceIDR = true;
1380         vEncSample->OUT_DIR = "/data/test/media/vbr_i.h264";
1381         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1382         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1383         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1384         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1385         vEncSample->WaitForEOS();
1386         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1387     }
1388 }
1389 /**
1390  * @tc.number    : COLORSPACE_CONFIG_001
1391  * @tc.name      : COLORSPACE
1392  * @tc.desc      : function test
1393  */
1394 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_001, TestSize.Level1)
1395 {
1396     auto vEncSample = make_unique<VEncAPI11Sample>();
1397     vEncSample->INP_DIR = INP_DIR_720;
1398     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1399     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1400     vEncSample->DEFAULT_BITRATE_MODE = VBR;
1401     vEncSample->DEFAULT_RANGE_FLAG = 1;
1402     vEncSample->enableColorSpaceParams = true;
1403     vEncSample->DEFAULT_COLOR_PRIMARIES = 100;
1404     vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = 10000;
1405     vEncSample->DEFAULT_MATRIX_COEFFICIENTS = 10000;
1406     vEncSample->OUT_DIR = "/data/test/media/vbr_i.h264";
1407     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1408     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1409     ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
1410     ASSERT_EQ(AV_ERR_INVALID_STATE, vEncSample->StartVideoEncoder());
1411     vEncSample->WaitForEOS();
1412     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1413 }
1414 /**
1415  * @tc.number    : COLORSPACE_CONFIG_002
1416  * @tc.name      : COLORSPACE 264
1417  * @tc.desc      : function test
1418  */
1419 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_002, TestSize.Level1)
1420 {
1421     auto vEncSample = make_unique<VEncAPI11Sample>();
1422     vEncSample->INP_DIR = INP_DIR_720;
1423     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1424     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1425     vEncSample->DEFAULT_BITRATE_MODE = VBR;
1426     vEncSample->DEFAULT_RANGE_FLAG = 1;
1427     vEncSample->enableColorSpaceParams = true;
1428     vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT709;
1429     vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_BT709;
1430     vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT709;
1431     vEncSample->OUT_DIR = "/data/test/media/bt_709_h264.h264";
1432     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1433     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1434     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1435     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1436     vEncSample->WaitForEOS();
1437     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1438 }
1439 /**
1440  * @tc.number    : COLORSPACE_CONFIG_003
1441  * @tc.name      : COLORSPACE 265
1442  * @tc.desc      : function test
1443  */
1444 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_003, TestSize.Level1)
1445 {
1446     auto vEncSample = make_unique<VEncAPI11Sample>();
1447     vEncSample->INP_DIR = INP_DIR_720;
1448     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1449     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1450     vEncSample->DEFAULT_BITRATE_MODE = VBR;
1451     vEncSample->DEFAULT_RANGE_FLAG = 1;
1452     vEncSample->enableColorSpaceParams = true;
1453     vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT709;
1454     vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_BT709;
1455     vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT709;
1456     vEncSample->OUT_DIR = "/data/test/media/bt_709_h265.h265";
1457     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1458     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1459     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1460     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1461     vEncSample->WaitForEOS();
1462     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1463 }
1464 /**
1465  * @tc.number    : COLORSPACE_CONFIG_004
1466  * @tc.name      : COLORSPACE 265
1467  * @tc.desc      : function test
1468  */
1469 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_004, TestSize.Level1)
1470 {
1471     auto vEncSample = make_unique<VEncAPI11Sample>();
1472     vEncSample->INP_DIR = INP_DIR_720;
1473     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1474     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1475     vEncSample->DEFAULT_BITRATE_MODE = VBR;
1476     vEncSample->DEFAULT_RANGE_FLAG = 0;
1477     vEncSample->enableColorSpaceParams = true;
1478     vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT2020;
1479     vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_PQ;
1480     vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT2020_NCL;
1481     vEncSample->OUT_DIR = "/data/test/media/bt_2020_PQ_h265.h265";
1482     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1483     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1484     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1485     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1486     vEncSample->WaitForEOS();
1487     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1488 }
1489 /**
1490  * @tc.number    : COLORSPACE_CONFIG_005
1491  * @tc.name      : COLORSPACE 265
1492  * @tc.desc      : function test
1493  */
1494 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_005, TestSize.Level1)
1495 {
1496     auto vEncSample = make_unique<VEncAPI11Sample>();
1497     vEncSample->INP_DIR = INP_DIR_720;
1498     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1499     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1500     vEncSample->DEFAULT_BITRATE_MODE = VBR;
1501     vEncSample->DEFAULT_RANGE_FLAG = 0;
1502     vEncSample->enableColorSpaceParams = true;
1503     vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT2020;
1504     vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_HLG;
1505     vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT2020_NCL;
1506     vEncSample->OUT_DIR = "/data/test/media/bt_2020_HLG_h265.h265";
1507     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1508     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1509     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1510     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1511     vEncSample->WaitForEOS();
1512     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1513 }
1514 /**
1515  * @tc.number    : COLORSPACE_CONFIG_006
1516  * @tc.name      : COLORSPACE 265
1517  * @tc.desc      : function test
1518  */
1519 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_006, TestSize.Level1)
1520 {
1521     auto vEncSample = make_unique<VEncAPI11Sample>();
1522     vEncSample->INP_DIR = INP_DIR_720;
1523     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1524     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1525     vEncSample->DEFAULT_BITRATE_MODE = VBR;
1526     vEncSample->DEFAULT_RANGE_FLAG = 0;
1527     vEncSample->enableColorSpaceParams = true;
1528     vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_P3D65;
1529     vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_PQ;
1530     vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT2020_NCL;
1531     vEncSample->OUT_DIR = "/data/test/media/bt_2020_P3D65_h265.h265";
1532     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1533     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1534     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1535     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1536     vEncSample->WaitForEOS();
1537     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1538 }
1539 }