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