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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_001, TestSize.Level1)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_002, TestSize.Level0)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_EQ(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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_003, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_004, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_005, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_006, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_007, TestSize.Level1)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_008, TestSize.Level0)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_EQ(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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_009, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_010, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_011, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_BITRATE_012, TestSize.Level0)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  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_001, TestSize.Level0)390 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_001, TestSize.Level0)
391 {
392     auto vEncSample = make_unique<VEncAPI11Sample>();
393     vEncSample->INP_DIR = INP_DIR_720;
394     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
395     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
396     vEncSample->DEFAULT_FRAME_RATE = 30;
397     vEncSample->DEFAULT_BITRATE_MODE = CQ;
398     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
399     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
400     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
401     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
402     OH_AVFormat *format = OH_AVFormat_Create();
403     (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, -1.0);
404     EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
405     OH_AVFormat_Destroy(format);
406     vEncSample->WaitForEOS();
407     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
408 }
409 
410 /**
411  * @tc.number    : RESET_FRAMERATE_002
412  * @tc.name      : reset framerate in CQ mode
413  * @tc.desc      : function test
414  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_002, TestSize.Level1)415 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_002, TestSize.Level1)
416 {
417     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
418         auto vEncSample = make_unique<VEncAPI11Sample>();
419         vEncSample->INP_DIR = INP_DIR_720;
420         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
421         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
422         vEncSample->DEFAULT_FRAME_RATE = 30;
423         vEncSample->enableAutoSwitchParam = true;
424         vEncSample->needResetFrameRate = true;
425         vEncSample->DEFAULT_BITRATE_MODE = CQ;
426         vEncSample->OUT_DIR = "/data/test/media/CQ_1s_r_.h264";
427         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
428         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
429         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
430         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
431         vEncSample->WaitForEOS();
432         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
433     }
434 }
435 
436 /**
437  * @tc.number    : RESET_FRAMERATE_003
438  * @tc.name      : reset framerate in CBR mode, gop size -1
439  * @tc.desc      : function test
440  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_003, TestSize.Level1)441 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_003, TestSize.Level1)
442 {
443     auto vEncSample = make_unique<VEncAPI11Sample>();
444     vEncSample->INP_DIR = INP_DIR_720;
445     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
446     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
447     vEncSample->DEFAULT_FRAME_RATE = 30;
448     vEncSample->enableAutoSwitchParam = true;
449     vEncSample->needResetFrameRate = true;
450     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
451     vEncSample->DEFAULT_BITRATE_MODE = CBR;
452     vEncSample->OUT_DIR = "/data/test/media/cbr_-1_r_.h264";
453     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
454     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
455     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
456     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
457     vEncSample->WaitForEOS();
458     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
459 }
460 
461 /**
462  * @tc.number    : RESET_FRAMERATE_004
463  * @tc.name      : reset framerate in CBR mode, gop size 0
464  * @tc.desc      : function test
465  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_004, TestSize.Level1)466 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_004, TestSize.Level1)
467 {
468     auto vEncSample = make_unique<VEncAPI11Sample>();
469     vEncSample->INP_DIR = INP_DIR_720;
470     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
471     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
472     vEncSample->DEFAULT_FRAME_RATE = 30;
473     vEncSample->enableAutoSwitchParam = true;
474     vEncSample->needResetFrameRate = true;
475     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
476     vEncSample->DEFAULT_BITRATE_MODE = CBR;
477     vEncSample->OUT_DIR = "/data/test/media/cbr_0_r_.h264";
478     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
479     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
480     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
481     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
482     vEncSample->WaitForEOS();
483     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
484 }
485 
486 /**
487  * @tc.number    : RESET_FRAMERATE_005
488  * @tc.name      : reset framerate in CBR mode, gop size 1s
489  * @tc.desc      : function test
490  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_005, TestSize.Level1)491 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_005, TestSize.Level1)
492 {
493     auto vEncSample = make_unique<VEncAPI11Sample>();
494     vEncSample->INP_DIR = INP_DIR_720;
495     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
496     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
497     vEncSample->DEFAULT_FRAME_RATE = 30;
498     vEncSample->enableAutoSwitchParam = true;
499     vEncSample->needResetFrameRate = true;
500     vEncSample->DEFAULT_BITRATE_MODE = CBR;
501     vEncSample->OUT_DIR = "/data/test/media/cbr_1s_r_.h264";
502     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
503     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
504     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
505     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
506     vEncSample->WaitForEOS();
507     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
508 }
509 
510 /**
511  * @tc.number    : RESET_FRAMERATE_006
512  * @tc.name      : reset framerate in VBR mode, gop size 1s
513  * @tc.desc      : function test
514  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_006, TestSize.Level1)515 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_006, TestSize.Level1)
516 {
517     auto vEncSample = make_unique<VEncAPI11Sample>();
518     vEncSample->INP_DIR = INP_DIR_720;
519     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
520     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
521     vEncSample->DEFAULT_FRAME_RATE = 30;
522     vEncSample->enableAutoSwitchParam = true;
523     vEncSample->needResetFrameRate = true;
524     vEncSample->DEFAULT_BITRATE_MODE = VBR;
525     vEncSample->OUT_DIR = "/data/test/media/vbr_1s_r_.h264";
526     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
527     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
528     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
529     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
530     vEncSample->WaitForEOS();
531     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
532 }
533 
534 
535 /**
536  * @tc.number    : RESET_FRAMERATE_007
537  * @tc.name      : reset framerate in CQ mode hevc
538  * @tc.desc      : function test
539  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_007, TestSize.Level1)540 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_007, TestSize.Level1)
541 {
542     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
543         auto vEncSample = make_unique<VEncAPI11Sample>();
544         vEncSample->INP_DIR = INP_DIR_720;
545         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
546         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
547         vEncSample->DEFAULT_FRAME_RATE = 30;
548         vEncSample->enableAutoSwitchParam = true;
549         vEncSample->needResetFrameRate = true;
550         vEncSample->DEFAULT_BITRATE_MODE = CQ;
551         vEncSample->OUT_DIR = "/data/test/media/CQ_1s_r_.h265";
552         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
553         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
554         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
555         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
556         vEncSample->WaitForEOS();
557         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
558     }
559 }
560 
561 /**
562  * @tc.number    : RESET_FRAMERATE_008
563  * @tc.name      : reset framerate in CBR mode, gop size -1 hevc
564  * @tc.desc      : function test
565  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_008, TestSize.Level1)566 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_008, TestSize.Level1)
567 {
568     auto vEncSample = make_unique<VEncAPI11Sample>();
569     vEncSample->INP_DIR = INP_DIR_720;
570     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
571     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
572     vEncSample->DEFAULT_FRAME_RATE = 30;
573     vEncSample->enableAutoSwitchParam = true;
574     vEncSample->needResetFrameRate = true;
575     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
576     vEncSample->DEFAULT_BITRATE_MODE = CBR;
577     vEncSample->OUT_DIR = "/data/test/media/cbr_-1_r_.h265";
578     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
579     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
580     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
581     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
582     vEncSample->WaitForEOS();
583     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
584 }
585 
586 /**
587  * @tc.number    : RESET_FRAMERATE_009
588  * @tc.name      : reset framerate in CBR mode, gop size 0 hevc
589  * @tc.desc      : function test
590  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_009, TestSize.Level1)591 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_009, TestSize.Level1)
592 {
593     auto vEncSample = make_unique<VEncAPI11Sample>();
594     vEncSample->INP_DIR = INP_DIR_720;
595     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
596     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
597     vEncSample->DEFAULT_FRAME_RATE = 30;
598     vEncSample->enableAutoSwitchParam = true;
599     vEncSample->needResetFrameRate = true;
600     vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
601     vEncSample->DEFAULT_BITRATE_MODE = CBR;
602     vEncSample->OUT_DIR = "/data/test/media/cbr_0_r_.h265";
603     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
604     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
605     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
606     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
607     vEncSample->WaitForEOS();
608     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
609 }
610 
611 /**
612  * @tc.number    : RESET_FRAMERATE_010
613  * @tc.name      : reset framerate in CBR mode, gop size 1s hevc
614  * @tc.desc      : function test
615  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_010, TestSize.Level1)616 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_010, TestSize.Level1)
617 {
618     auto vEncSample = make_unique<VEncAPI11Sample>();
619     vEncSample->INP_DIR = INP_DIR_720;
620     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
621     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
622     vEncSample->DEFAULT_FRAME_RATE = 30;
623     vEncSample->enableAutoSwitchParam = true;
624     vEncSample->needResetFrameRate = true;
625     vEncSample->DEFAULT_BITRATE_MODE = CBR;
626     vEncSample->OUT_DIR = "/data/test/media/cbr_1s_r_.h265";
627     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
628     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
629     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
630     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
631     vEncSample->WaitForEOS();
632     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
633 }
634 
635 /**
636  * @tc.number    : RESET_FRAMERATE_011
637  * @tc.name      : reset framerate in VBR mode, gop size 1s hevc
638  * @tc.desc      : function test
639  */
HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_011, TestSize.Level1)640 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_011, TestSize.Level1)
641 {
642     auto vEncSample = make_unique<VEncAPI11Sample>();
643     vEncSample->INP_DIR = INP_DIR_720;
644     vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
645     vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
646     vEncSample->DEFAULT_FRAME_RATE = 30;
647     vEncSample->enableAutoSwitchParam = true;
648     vEncSample->needResetFrameRate = true;
649     vEncSample->DEFAULT_BITRATE_MODE = VBR;
650     vEncSample->OUT_DIR = "/data/test/media/vbr_1s_r_.h265";
651     ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
652     ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
653     ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
654     ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
655     vEncSample->WaitForEOS();
656     ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
657 }
658 
659 /**
660  * @tc.number    : RESET_QP_001
661  * @tc.name      : reset QP with illegal parameter
662  * @tc.desc      : function test
663  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_001, TestSize.Level1)664 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_001, TestSize.Level1)
665 {
666     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
667         auto vEncSample = make_unique<VEncAPI11Sample>();
668         vEncSample->INP_DIR = INP_DIR_720;
669         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
670         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
671         vEncSample->DEFAULT_FRAME_RATE = 30;
672         vEncSample->DEFAULT_BITRATE_MODE = CQ;
673         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
674         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
675         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
676         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
677         OH_AVFormat *format = OH_AVFormat_Create();
678         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, -1);
679         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, -1);
680         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
681         OH_AVFormat_Destroy(format);
682         format = OH_AVFormat_Create();
683         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, 200);
684         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, 200);
685         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
686         OH_AVFormat_Destroy(format);
687         vEncSample->WaitForEOS();
688         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
689     }
690 }
691 /**
692  * @tc.number    : RESET_QP_002
693  * @tc.name      : reset QP with illegal parameter
694  * @tc.desc      : function test
695  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_002, TestSize.Level1)696 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_002, TestSize.Level1)
697 {
698     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
699         auto vEncSample = make_unique<VEncAPI11Sample>();
700         vEncSample->INP_DIR = INP_DIR_720;
701         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
702         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
703         vEncSample->DEFAULT_FRAME_RATE = 30;
704         vEncSample->DEFAULT_BITRATE_MODE = CQ;
705         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
706         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
707         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
708         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
709         OH_AVFormat *format = OH_AVFormat_Create();
710         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, -1);
711         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, -1);
712         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
713         OH_AVFormat_Destroy(format);
714         format = OH_AVFormat_Create();
715         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, 200);
716         (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, 200);
717         EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
718         OH_AVFormat_Destroy(format);
719         vEncSample->WaitForEOS();
720         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
721     }
722 }
723 
724 /**
725  * @tc.number    : RESET_QP_003
726  * @tc.name      : reset QP in cq mode, use buffer->setparameter
727  * @tc.desc      : function test
728  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_003, TestSize.Level1)729 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_003, TestSize.Level1)
730 {
731     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
732         auto vEncSample = make_unique<VEncAPI11Sample>();
733         vEncSample->INP_DIR = INP_DIR_720;
734         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
735         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
736         vEncSample->DEFAULT_FRAME_RATE = 10;
737         vEncSample->DEFAULT_BITRATE_MODE = CQ;
738         vEncSample->enableAutoSwitchBufferParam = true;
739         vEncSample->needResetQP = true;
740         vEncSample->switchParamsTimeSec = 1;
741         vEncSample->OUT_DIR = "/data/test/media/cq_qp_b_.h264";
742         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
743         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
744         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
745         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
746         vEncSample->WaitForEOS();
747         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
748     }
749 }
750 
751 /**
752  * @tc.number    : RESET_QP_004
753  * @tc.name      : reset QP in CQ mode, use setparameter
754  * @tc.desc      : function test
755  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_004, TestSize.Level1)756 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_004, TestSize.Level1)
757 {
758     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
759         auto vEncSample = make_unique<VEncAPI11Sample>();
760         vEncSample->INP_DIR = INP_DIR_720;
761         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
762         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
763         vEncSample->DEFAULT_FRAME_RATE = 10;
764         vEncSample->DEFAULT_BITRATE_MODE = CQ;
765         vEncSample->enableAutoSwitchParam = true;
766         vEncSample->needResetQP = true;
767         vEncSample->switchParamsTimeSec = 1;
768         vEncSample->OUT_DIR = "/data/test/media/cq_qp_.h264";
769         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
770         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
771         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
772         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
773         vEncSample->WaitForEOS();
774         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
775     }
776 }
777 
778 /**
779  * @tc.number    : RESET_QP_005
780  * @tc.name      : reset QP in CBR mode, use buffer->setparameter
781  * @tc.desc      : function test
782  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_005, TestSize.Level1)783 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_005, TestSize.Level1)
784 {
785     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
786         auto vEncSample = make_unique<VEncAPI11Sample>();
787         vEncSample->INP_DIR = INP_DIR_720;
788         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
789         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
790         vEncSample->DEFAULT_FRAME_RATE = 10;
791         vEncSample->DEFAULT_BITRATE_MODE = CBR;
792         vEncSample->enableAutoSwitchBufferParam = true;
793         vEncSample->needResetQP = true;
794         vEncSample->switchParamsTimeSec = 1;
795         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_b_.h264";
796         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
797         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
798         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
799         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
800         vEncSample->WaitForEOS();
801         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
802     }
803 }
804 
805 /**
806  * @tc.number    : RESET_QP_006
807  * @tc.name      : reset QP in CBR mode, use setparameter
808  * @tc.desc      : function test
809  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_006, TestSize.Level1)810 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_006, TestSize.Level1)
811 {
812     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
813         auto vEncSample = make_unique<VEncAPI11Sample>();
814         vEncSample->INP_DIR = INP_DIR_720;
815         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
816         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
817         vEncSample->DEFAULT_FRAME_RATE = 10;
818         vEncSample->DEFAULT_BITRATE_MODE = CBR;
819         vEncSample->enableAutoSwitchParam = true;
820         vEncSample->needResetQP = true;
821         vEncSample->switchParamsTimeSec = 1;
822         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_.h264";
823         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
824         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
825         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
826         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
827         vEncSample->WaitForEOS();
828         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
829     }
830 }
831 
832 /**
833  * @tc.number    : RESET_QP_007
834  * @tc.name      : reset QP in VBR mode, use buffer->setparameter
835  * @tc.desc      : function test
836  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_007, TestSize.Level1)837 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_007, TestSize.Level1)
838 {
839     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
840         auto vEncSample = make_unique<VEncAPI11Sample>();
841         vEncSample->INP_DIR = INP_DIR_720;
842         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
843         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
844         vEncSample->DEFAULT_FRAME_RATE = 10;
845         vEncSample->DEFAULT_BITRATE_MODE = VBR;
846         vEncSample->enableAutoSwitchBufferParam = true;
847         vEncSample->needResetQP = true;
848         vEncSample->switchParamsTimeSec = 1;
849         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_b_.h264";
850         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
851         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
852         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
853         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
854         vEncSample->WaitForEOS();
855         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
856     }
857 }
858 
859 /**
860  * @tc.number    : RESET_QP_008
861  * @tc.name      : reset QP in VBR mode, use setparameter
862  * @tc.desc      : function test
863  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_008, TestSize.Level1)864 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_008, TestSize.Level1)
865 {
866     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
867         auto vEncSample = make_unique<VEncAPI11Sample>();
868         vEncSample->INP_DIR = INP_DIR_720;
869         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
870         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
871         vEncSample->DEFAULT_FRAME_RATE = 10;
872         vEncSample->DEFAULT_BITRATE_MODE = VBR;
873         vEncSample->enableAutoSwitchParam = true;
874         vEncSample->needResetQP = true;
875         vEncSample->switchParamsTimeSec = 1;
876         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_.h264";
877         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
878         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
879         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
880         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
881         vEncSample->WaitForEOS();
882         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
883     }
884 }
885 
886 /**
887  * @tc.number    : RESET_QP_009
888  * @tc.name      : reset QP in cq mode, use buffer->setparameter H265
889  * @tc.desc      : function test
890  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_009, TestSize.Level1)891 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_009, TestSize.Level1)
892 {
893     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
894         auto vEncSample = make_unique<VEncAPI11Sample>();
895         vEncSample->INP_DIR = INP_DIR_720;
896         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
897         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
898         vEncSample->DEFAULT_FRAME_RATE = 10;
899         vEncSample->DEFAULT_BITRATE_MODE = CQ;
900         vEncSample->enableAutoSwitchBufferParam = true;
901         vEncSample->needResetQP = true;
902         vEncSample->switchParamsTimeSec = 1;
903         vEncSample->OUT_DIR = "/data/test/media/cq_qp_b_.h265";
904         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
905         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
906         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
907         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
908         vEncSample->WaitForEOS();
909         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
910     }
911 }
912 
913 /**
914  * @tc.number    : RESET_QP_010
915  * @tc.name      : reset QP in CQ mode, use setparameter H265
916  * @tc.desc      : function test
917  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_010, TestSize.Level1)918 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_010, TestSize.Level1)
919 {
920     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
921         auto vEncSample = make_unique<VEncAPI11Sample>();
922         vEncSample->INP_DIR = INP_DIR_720;
923         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
924         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
925         vEncSample->DEFAULT_FRAME_RATE = 10;
926         vEncSample->DEFAULT_BITRATE_MODE = CQ;
927         vEncSample->enableAutoSwitchParam = true;
928         vEncSample->needResetQP = true;
929         vEncSample->switchParamsTimeSec = 1;
930         vEncSample->OUT_DIR = "/data/test/media/cq_qp_.h265";
931         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
932         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
933         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
934         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
935         vEncSample->WaitForEOS();
936         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
937     }
938 }
939 
940 /**
941  * @tc.number    : RESET_QP_011
942  * @tc.name      : reset QP in CBR mode, use buffer->setparameter h265
943  * @tc.desc      : function test
944  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_011, TestSize.Level1)945 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_011, TestSize.Level1)
946 {
947     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
948         auto vEncSample = make_unique<VEncAPI11Sample>();
949         vEncSample->INP_DIR = INP_DIR_720;
950         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
951         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
952         vEncSample->DEFAULT_FRAME_RATE = 10;
953         vEncSample->DEFAULT_BITRATE_MODE = CBR;
954         vEncSample->enableAutoSwitchBufferParam = true;
955         vEncSample->needResetQP = true;
956         vEncSample->switchParamsTimeSec = 1;
957         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_b_.h265";
958         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
959         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
960         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
961         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
962         vEncSample->WaitForEOS();
963         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
964     }
965 }
966 
967 /**
968  * @tc.number    : RESET_QP_012
969  * @tc.name      : reset QP in CBR mode, use setparameter h265
970  * @tc.desc      : function test
971  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_012, TestSize.Level1)972 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_012, TestSize.Level1)
973 {
974     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
975         auto vEncSample = make_unique<VEncAPI11Sample>();
976         vEncSample->INP_DIR = INP_DIR_720;
977         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
978         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
979         vEncSample->DEFAULT_FRAME_RATE = 10;
980         vEncSample->DEFAULT_BITRATE_MODE = CBR;
981         vEncSample->enableAutoSwitchParam = true;
982         vEncSample->needResetQP = true;
983         vEncSample->switchParamsTimeSec = 1;
984         vEncSample->OUT_DIR = "/data/test/media/cbr_qp_.h265";
985         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
986         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
987         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
988         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
989         vEncSample->WaitForEOS();
990         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
991     }
992 }
993 
994 /**
995  * @tc.number    : RESET_QP_013
996  * @tc.name      : reset QP in VBR mode, use buffer->setparameter h265
997  * @tc.desc      : function test
998  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_013, TestSize.Level1)999 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_013, TestSize.Level1)
1000 {
1001     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1002         auto vEncSample = make_unique<VEncAPI11Sample>();
1003         vEncSample->INP_DIR = INP_DIR_720;
1004         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1005         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1006         vEncSample->DEFAULT_FRAME_RATE = 10;
1007         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1008         vEncSample->enableAutoSwitchBufferParam = true;
1009         vEncSample->needResetQP = true;
1010         vEncSample->switchParamsTimeSec = 1;
1011         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_b_.h265";
1012         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1013         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1014         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1015         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1016         vEncSample->WaitForEOS();
1017         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1018     }
1019 }
1020 
1021 /**
1022  * @tc.number    : RESET_QP_014
1023  * @tc.name      : reset QP in VBR mode, use setparameter h265
1024  * @tc.desc      : function test
1025  */
HWTEST_F(HwEncSetParamNdkTest, RESET_QP_014, TestSize.Level1)1026 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_014, TestSize.Level1)
1027 {
1028     if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1029         auto vEncSample = make_unique<VEncAPI11Sample>();
1030         vEncSample->INP_DIR = INP_DIR_720;
1031         vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1032         vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1033         vEncSample->DEFAULT_FRAME_RATE = 10;
1034         vEncSample->DEFAULT_BITRATE_MODE = VBR;
1035         vEncSample->enableAutoSwitchParam = true;
1036         vEncSample->needResetQP = true;
1037         vEncSample->switchParamsTimeSec = 1;
1038         vEncSample->OUT_DIR = "/data/test/media/vbr_qp_.h265";
1039         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1040         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1041         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1042         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1043         vEncSample->WaitForEOS();
1044         ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1045     }
1046 }
1047 }