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