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 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_CQ);
470 if (isSupported) {
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->DEFAULT_BITRATE_MODE = CQ;
476 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
477 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
478 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
479 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
480 OH_AVFormat *format = OH_AVFormat_Create();
481 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, -1.0);
482 EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
483 OH_AVFormat_Destroy(format);
484 vEncSample->WaitForEOS();
485 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
486 }
487 }
488 }
489 /**
490 * @tc.number : RESET_FRAMERATE_013
491 * @tc.name : reset framerate use max value
492 * @tc.desc : function test
493 */
494 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_013, TestSize.Level0)
495 {
496 if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
497 auto vEncSample = make_unique<VEncAPI11Sample>();
498 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_CQ);
499 if (isSupported) {
500 vEncSample->INP_DIR = INP_DIR_720;
501 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
502 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
503 vEncSample->DEFAULT_FRAME_RATE = 30;
504 vEncSample->DEFAULT_BITRATE_MODE = CQ;
505 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
506 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
507 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
508 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
509 OH_AVFormat *format = OH_AVFormat_Create();
510 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DBL_MAX);
511 EXPECT_EQ(AV_ERR_OK, vEncSample->SetParameter(format));
512 OH_AVFormat_Destroy(format);
513 vEncSample->WaitForEOS();
514 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
515 }
516 }
517 }
518 /**
519 * @tc.number : RESET_FRAMERATE_014
520 * @tc.name : reset framerate use max value
521 * @tc.desc : function test
522 */
523 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_014, TestSize.Level0)
524 {
525 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
526 auto vEncSample = make_unique<VEncAPI11Sample>();
527 vEncSample->INP_DIR = INP_DIR_720;
528 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
529 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
530 vEncSample->DEFAULT_FRAME_RATE = 30;
531 vEncSample->DEFAULT_BITRATE_MODE = CQ;
532 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
533 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
534 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
535 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
536 OH_AVFormat *format = OH_AVFormat_Create();
537 (void)OH_AVFormat_SetDoubleValue(format, OH_MD_KEY_FRAME_RATE, DBL_MAX);
538 EXPECT_EQ(AV_ERR_OK, vEncSample->SetParameter(format));
539 OH_AVFormat_Destroy(format);
540 vEncSample->WaitForEOS();
541 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
542 }
543 }
544 /**
545 * @tc.number : RESET_FRAMERATE_002
546 * @tc.name : reset framerate in CQ mode
547 * @tc.desc : function test
548 */
549 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_002, TestSize.Level1)
550 {
551 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
552 auto vEncSample = make_unique<VEncAPI11Sample>();
553 vEncSample->INP_DIR = INP_DIR_720;
554 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
555 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
556 vEncSample->DEFAULT_FRAME_RATE = 30;
557 vEncSample->enableAutoSwitchParam = true;
558 vEncSample->needResetFrameRate = true;
559 vEncSample->DEFAULT_BITRATE_MODE = CQ;
560 vEncSample->OUT_DIR = "/data/test/media/CQ_1s_r_.h264";
561 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
562 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
563 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
564 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
565 vEncSample->WaitForEOS();
566 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
567 }
568 }
569
570 /**
571 * @tc.number : RESET_FRAMERATE_003
572 * @tc.name : reset framerate in CBR mode, gop size -1
573 * @tc.desc : function test
574 */
575 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_003, TestSize.Level1)
576 {
577 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
578 if (cap) {
579 auto vEncSample = make_unique<VEncAPI11Sample>();
580 vEncSample->INP_DIR = INP_DIR_720;
581 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
582 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
583 vEncSample->DEFAULT_FRAME_RATE = 30;
584 vEncSample->enableAutoSwitchParam = true;
585 vEncSample->needResetFrameRate = true;
586 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
587 vEncSample->DEFAULT_BITRATE_MODE = CBR;
588 vEncSample->OUT_DIR = "/data/test/media/cbr_-1_r_.h264";
589 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
590 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
591 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
592 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
593 vEncSample->WaitForEOS();
594 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
595 } else {
596 return;
597 }
598 }
599
600 /**
601 * @tc.number : RESET_FRAMERATE_004
602 * @tc.name : reset framerate in CBR mode, gop size 0
603 * @tc.desc : function test
604 */
605 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_004, TestSize.Level1)
606 {
607 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
608 if (cap) {
609 auto vEncSample = make_unique<VEncAPI11Sample>();
610 vEncSample->INP_DIR = INP_DIR_720;
611 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
612 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
613 vEncSample->DEFAULT_FRAME_RATE = 30;
614 vEncSample->enableAutoSwitchParam = true;
615 vEncSample->needResetFrameRate = true;
616 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
617 vEncSample->DEFAULT_BITRATE_MODE = CBR;
618 vEncSample->OUT_DIR = "/data/test/media/cbr_0_r_.h264";
619 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
620 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
621 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
622 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
623 vEncSample->WaitForEOS();
624 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
625 } else {
626 return;
627 }
628 }
629
630 /**
631 * @tc.number : RESET_FRAMERATE_005
632 * @tc.name : reset framerate in CBR mode, gop size 1s
633 * @tc.desc : function test
634 */
635 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_005, TestSize.Level1)
636 {
637 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
638 if (cap) {
639 auto vEncSample = make_unique<VEncAPI11Sample>();
640 vEncSample->INP_DIR = INP_DIR_720;
641 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
642 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
643 vEncSample->DEFAULT_FRAME_RATE = 30;
644 vEncSample->enableAutoSwitchParam = true;
645 vEncSample->needResetFrameRate = true;
646 vEncSample->DEFAULT_BITRATE_MODE = CBR;
647 vEncSample->OUT_DIR = "/data/test/media/cbr_1s_r_.h264";
648 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
649 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
650 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
651 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
652 vEncSample->WaitForEOS();
653 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
654 } else {
655 return;
656 }
657 }
658
659 /**
660 * @tc.number : RESET_FRAMERATE_006
661 * @tc.name : reset framerate in VBR mode, gop size 1s
662 * @tc.desc : function test
663 */
664 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_006, TestSize.Level1)
665 {
666 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
667 if (cap) {
668 auto vEncSample = make_unique<VEncAPI11Sample>();
669 vEncSample->INP_DIR = INP_DIR_720;
670 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
671 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
672 vEncSample->DEFAULT_FRAME_RATE = 30;
673 vEncSample->enableAutoSwitchParam = true;
674 vEncSample->needResetFrameRate = true;
675 vEncSample->DEFAULT_BITRATE_MODE = VBR;
676 vEncSample->OUT_DIR = "/data/test/media/vbr_1s_r_.h264";
677 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
678 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
679 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
680 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
681 vEncSample->WaitForEOS();
682 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
683 } else {
684 return;
685 }
686 }
687
688 /**
689 * @tc.number : RESET_FRAMERATE_007
690 * @tc.name : reset framerate in CQ mode hevc
691 * @tc.desc : function test
692 */
693 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_007, TestSize.Level1)
694 {
695 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
696 auto vEncSample = make_unique<VEncAPI11Sample>();
697 vEncSample->INP_DIR = INP_DIR_720;
698 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
699 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
700 vEncSample->DEFAULT_FRAME_RATE = 30;
701 vEncSample->enableAutoSwitchParam = true;
702 vEncSample->needResetFrameRate = true;
703 vEncSample->DEFAULT_BITRATE_MODE = CQ;
704 vEncSample->OUT_DIR = "/data/test/media/CQ_1s_r_.h265";
705 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
706 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
707 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
708 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
709 vEncSample->WaitForEOS();
710 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
711 }
712 }
713
714 /**
715 * @tc.number : RESET_FRAMERATE_008
716 * @tc.name : reset framerate in CBR mode, gop size -1 hevc
717 * @tc.desc : function test
718 */
719 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_008, TestSize.Level1)
720 {
721 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
722 if (cap) {
723 auto vEncSample = make_unique<VEncAPI11Sample>();
724 vEncSample->INP_DIR = INP_DIR_720;
725 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
726 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
727 vEncSample->DEFAULT_FRAME_RATE = 30;
728 vEncSample->enableAutoSwitchParam = true;
729 vEncSample->needResetFrameRate = true;
730 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = -1;
731 vEncSample->DEFAULT_BITRATE_MODE = CBR;
732 vEncSample->OUT_DIR = "/data/test/media/cbr_-1_r_.h265";
733 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
734 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
735 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
736 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
737 vEncSample->WaitForEOS();
738 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
739 } else {
740 return;
741 }
742 }
743
744 /**
745 * @tc.number : RESET_FRAMERATE_009
746 * @tc.name : reset framerate in CBR mode, gop size 0 hevc
747 * @tc.desc : function test
748 */
749 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_009, TestSize.Level1)
750 {
751 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
752 if (cap) {
753 auto vEncSample = make_unique<VEncAPI11Sample>();
754 vEncSample->INP_DIR = INP_DIR_720;
755 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
756 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
757 vEncSample->DEFAULT_FRAME_RATE = 30;
758 vEncSample->enableAutoSwitchParam = true;
759 vEncSample->needResetFrameRate = true;
760 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 0;
761 vEncSample->DEFAULT_BITRATE_MODE = CBR;
762 vEncSample->OUT_DIR = "/data/test/media/cbr_0_r_.h265";
763 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
764 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
765 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
766 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
767 vEncSample->WaitForEOS();
768 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
769 } else {
770 return;
771 }
772 }
773
774 /**
775 * @tc.number : RESET_FRAMERATE_010
776 * @tc.name : reset framerate in CBR mode, gop size 1s hevc
777 * @tc.desc : function test
778 */
779 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_010, TestSize.Level1)
780 {
781 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
782 if (cap) {
783 auto vEncSample = make_unique<VEncAPI11Sample>();
784 vEncSample->INP_DIR = INP_DIR_720;
785 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
786 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
787 vEncSample->DEFAULT_FRAME_RATE = 30;
788 vEncSample->enableAutoSwitchParam = true;
789 vEncSample->needResetFrameRate = true;
790 vEncSample->DEFAULT_BITRATE_MODE = CBR;
791 vEncSample->OUT_DIR = "/data/test/media/cbr_1s_r_.h265";
792 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
793 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
794 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
795 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
796 vEncSample->WaitForEOS();
797 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
798 } else {
799 return;
800 }
801 }
802
803 /**
804 * @tc.number : RESET_FRAMERATE_011
805 * @tc.name : reset framerate in VBR mode, gop size 1s hevc
806 * @tc.desc : function test
807 */
808 HWTEST_F(HwEncSetParamNdkTest, RESET_FRAMERATE_011, TestSize.Level1)
809 {
810 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
811 if (cap) {
812 auto vEncSample = make_unique<VEncAPI11Sample>();
813 vEncSample->INP_DIR = INP_DIR_720;
814 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
815 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
816 vEncSample->DEFAULT_FRAME_RATE = 30;
817 vEncSample->enableAutoSwitchParam = true;
818 vEncSample->needResetFrameRate = true;
819 vEncSample->DEFAULT_BITRATE_MODE = VBR;
820 vEncSample->OUT_DIR = "/data/test/media/vbr_1s_r_.h265";
821 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
822 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
823 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
824 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
825 vEncSample->WaitForEOS();
826 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
827 } else {
828 return;
829 }
830 }
831
832 /**
833 * @tc.number : RESET_QP_001
834 * @tc.name : reset QP with illegal parameter
835 * @tc.desc : function test
836 */
837 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_001, TestSize.Level1)
838 {
839 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
840 auto vEncSample = make_unique<VEncAPI11Sample>();
841 vEncSample->INP_DIR = INP_DIR_720;
842 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
843 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
844 vEncSample->DEFAULT_FRAME_RATE = 30;
845 vEncSample->DEFAULT_BITRATE_MODE = CQ;
846 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
847 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
848 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
849 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
850 OH_AVFormat *format = OH_AVFormat_Create();
851 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, -1);
852 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, -1);
853 EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
854 OH_AVFormat_Destroy(format);
855 format = OH_AVFormat_Create();
856 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, 200);
857 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, 200);
858 EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
859 OH_AVFormat_Destroy(format);
860 vEncSample->WaitForEOS();
861 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
862 }
863 }
864 /**
865 * @tc.number : RESET_QP_002
866 * @tc.name : reset QP with illegal parameter
867 * @tc.desc : function test
868 */
869 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_002, TestSize.Level1)
870 {
871 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
872 auto vEncSample = make_unique<VEncAPI11Sample>();
873 vEncSample->INP_DIR = INP_DIR_720;
874 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
875 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
876 vEncSample->DEFAULT_FRAME_RATE = 30;
877 vEncSample->DEFAULT_BITRATE_MODE = CQ;
878 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
879 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
880 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
881 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
882 OH_AVFormat *format = OH_AVFormat_Create();
883 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, -1);
884 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, -1);
885 EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
886 OH_AVFormat_Destroy(format);
887 format = OH_AVFormat_Create();
888 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MAX, 200);
889 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODER_QP_MIN, 200);
890 EXPECT_EQ(AV_ERR_INVALID_VAL, vEncSample->SetParameter(format));
891 OH_AVFormat_Destroy(format);
892 vEncSample->WaitForEOS();
893 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
894 }
895 }
896
897 /**
898 * @tc.number : RESET_QP_003
899 * @tc.name : reset QP in cq mode, use buffer->setparameter
900 * @tc.desc : function test
901 */
902 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_003, TestSize.Level1)
903 {
904 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
905 auto vEncSample = make_unique<VEncAPI11Sample>();
906 vEncSample->INP_DIR = INP_DIR_720;
907 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
908 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
909 vEncSample->DEFAULT_FRAME_RATE = 10;
910 vEncSample->DEFAULT_BITRATE_MODE = CQ;
911 vEncSample->enableAutoSwitchBufferParam = true;
912 vEncSample->needResetQP = true;
913 vEncSample->switchParamsTimeSec = 1;
914 vEncSample->OUT_DIR = "/data/test/media/cq_qp_b_.h264";
915 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
916 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
917 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
918 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
919 vEncSample->WaitForEOS();
920 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
921 }
922 }
923
924 /**
925 * @tc.number : RESET_QP_004
926 * @tc.name : reset QP in CQ mode, use setparameter
927 * @tc.desc : function test
928 */
929 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_004, TestSize.Level1)
930 {
931 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
932 auto vEncSample = make_unique<VEncAPI11Sample>();
933 vEncSample->INP_DIR = INP_DIR_720;
934 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
935 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
936 vEncSample->DEFAULT_FRAME_RATE = 10;
937 vEncSample->DEFAULT_BITRATE_MODE = CQ;
938 vEncSample->enableAutoSwitchParam = true;
939 vEncSample->needResetQP = true;
940 vEncSample->switchParamsTimeSec = 1;
941 vEncSample->OUT_DIR = "/data/test/media/cq_qp_.h264";
942 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
943 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
944 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
945 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
946 vEncSample->WaitForEOS();
947 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
948 }
949 }
950
951 /**
952 * @tc.number : RESET_QP_005
953 * @tc.name : reset QP in CBR mode, use buffer->setparameter
954 * @tc.desc : function test
955 */
956 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_005, TestSize.Level1)
957 {
958 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
959 auto vEncSample = make_unique<VEncAPI11Sample>();
960 vEncSample->INP_DIR = INP_DIR_720;
961 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
962 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
963 vEncSample->DEFAULT_FRAME_RATE = 10;
964 vEncSample->DEFAULT_BITRATE_MODE = CBR;
965 vEncSample->enableAutoSwitchBufferParam = true;
966 vEncSample->needResetQP = true;
967 vEncSample->switchParamsTimeSec = 1;
968 vEncSample->OUT_DIR = "/data/test/media/cbr_qp_b_.h264";
969 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
970 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
971 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
972 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
973 vEncSample->WaitForEOS();
974 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
975 }
976 }
977
978 /**
979 * @tc.number : RESET_QP_006
980 * @tc.name : reset QP in CBR mode, use setparameter
981 * @tc.desc : function test
982 */
983 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_006, TestSize.Level1)
984 {
985 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
986 auto vEncSample = make_unique<VEncAPI11Sample>();
987 vEncSample->INP_DIR = INP_DIR_720;
988 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
989 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
990 vEncSample->DEFAULT_FRAME_RATE = 10;
991 vEncSample->DEFAULT_BITRATE_MODE = CBR;
992 vEncSample->enableAutoSwitchParam = true;
993 vEncSample->needResetQP = true;
994 vEncSample->switchParamsTimeSec = 1;
995 vEncSample->OUT_DIR = "/data/test/media/cbr_qp_.h264";
996 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
997 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
998 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
999 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1000 vEncSample->WaitForEOS();
1001 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1002 }
1003 }
1004
1005 /**
1006 * @tc.number : RESET_QP_007
1007 * @tc.name : reset QP in VBR mode, use buffer->setparameter
1008 * @tc.desc : function test
1009 */
1010 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_007, TestSize.Level1)
1011 {
1012 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1013 auto vEncSample = make_unique<VEncAPI11Sample>();
1014 vEncSample->INP_DIR = INP_DIR_720;
1015 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1016 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1017 vEncSample->DEFAULT_FRAME_RATE = 10;
1018 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1019 vEncSample->enableAutoSwitchBufferParam = true;
1020 vEncSample->needResetQP = true;
1021 vEncSample->switchParamsTimeSec = 1;
1022 vEncSample->OUT_DIR = "/data/test/media/vbr_qp_b_.h264";
1023 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1024 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1025 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1026 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1027 vEncSample->WaitForEOS();
1028 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1029 }
1030 }
1031
1032 /**
1033 * @tc.number : RESET_QP_008
1034 * @tc.name : reset QP in VBR mode, use setparameter
1035 * @tc.desc : function test
1036 */
1037 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_008, TestSize.Level1)
1038 {
1039 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1040 auto vEncSample = make_unique<VEncAPI11Sample>();
1041 vEncSample->INP_DIR = INP_DIR_720;
1042 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1043 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1044 vEncSample->DEFAULT_FRAME_RATE = 10;
1045 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1046 vEncSample->enableAutoSwitchParam = true;
1047 vEncSample->needResetQP = true;
1048 vEncSample->switchParamsTimeSec = 1;
1049 vEncSample->OUT_DIR = "/data/test/media/vbr_qp_.h264";
1050 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1051 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1052 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1053 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1054 vEncSample->WaitForEOS();
1055 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1056 }
1057 }
1058
1059 /**
1060 * @tc.number : RESET_QP_009
1061 * @tc.name : reset QP in cq mode, use buffer->setparameter H265
1062 * @tc.desc : function test
1063 */
1064 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_009, TestSize.Level1)
1065 {
1066 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1067 auto vEncSample = make_unique<VEncAPI11Sample>();
1068 vEncSample->INP_DIR = INP_DIR_720;
1069 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1070 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1071 vEncSample->DEFAULT_FRAME_RATE = 10;
1072 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1073 vEncSample->enableAutoSwitchBufferParam = true;
1074 vEncSample->needResetQP = true;
1075 vEncSample->switchParamsTimeSec = 1;
1076 vEncSample->OUT_DIR = "/data/test/media/cq_qp_b_.h265";
1077 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1078 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1079 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1080 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1081 vEncSample->WaitForEOS();
1082 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1083 }
1084 }
1085
1086 /**
1087 * @tc.number : RESET_QP_010
1088 * @tc.name : reset QP in CQ mode, use setparameter H265
1089 * @tc.desc : function test
1090 */
1091 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_010, TestSize.Level1)
1092 {
1093 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1094 auto vEncSample = make_unique<VEncAPI11Sample>();
1095 vEncSample->INP_DIR = INP_DIR_720;
1096 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1097 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1098 vEncSample->DEFAULT_FRAME_RATE = 10;
1099 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1100 vEncSample->enableAutoSwitchParam = true;
1101 vEncSample->needResetQP = true;
1102 vEncSample->switchParamsTimeSec = 1;
1103 vEncSample->OUT_DIR = "/data/test/media/cq_qp_.h265";
1104 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1105 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1106 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1107 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1108 vEncSample->WaitForEOS();
1109 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1110 }
1111 }
1112
1113 /**
1114 * @tc.number : RESET_QP_011
1115 * @tc.name : reset QP in CBR mode, use buffer->setparameter h265
1116 * @tc.desc : function test
1117 */
1118 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_011, TestSize.Level1)
1119 {
1120 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1121 auto vEncSample = make_unique<VEncAPI11Sample>();
1122 vEncSample->INP_DIR = INP_DIR_720;
1123 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1124 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1125 vEncSample->DEFAULT_FRAME_RATE = 10;
1126 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1127 vEncSample->enableAutoSwitchBufferParam = true;
1128 vEncSample->needResetQP = true;
1129 vEncSample->switchParamsTimeSec = 1;
1130 vEncSample->OUT_DIR = "/data/test/media/cbr_qp_b_.h265";
1131 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1132 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1133 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1134 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1135 vEncSample->WaitForEOS();
1136 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1137 }
1138 }
1139
1140 /**
1141 * @tc.number : RESET_QP_012
1142 * @tc.name : reset QP in CBR mode, use setparameter h265
1143 * @tc.desc : function test
1144 */
1145 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_012, TestSize.Level1)
1146 {
1147 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1148 auto vEncSample = make_unique<VEncAPI11Sample>();
1149 vEncSample->INP_DIR = INP_DIR_720;
1150 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1151 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1152 vEncSample->DEFAULT_FRAME_RATE = 10;
1153 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1154 vEncSample->enableAutoSwitchParam = true;
1155 vEncSample->needResetQP = true;
1156 vEncSample->switchParamsTimeSec = 1;
1157 vEncSample->OUT_DIR = "/data/test/media/cbr_qp_.h265";
1158 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1159 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1160 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1161 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1162 vEncSample->WaitForEOS();
1163 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1164 }
1165 }
1166
1167 /**
1168 * @tc.number : RESET_QP_013
1169 * @tc.name : reset QP in VBR mode, use buffer->setparameter h265
1170 * @tc.desc : function test
1171 */
1172 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_013, TestSize.Level1)
1173 {
1174 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1175 auto vEncSample = make_unique<VEncAPI11Sample>();
1176 vEncSample->INP_DIR = INP_DIR_720;
1177 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1178 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1179 vEncSample->DEFAULT_FRAME_RATE = 10;
1180 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1181 vEncSample->enableAutoSwitchBufferParam = true;
1182 vEncSample->needResetQP = true;
1183 vEncSample->switchParamsTimeSec = 1;
1184 vEncSample->OUT_DIR = "/data/test/media/vbr_qp_b_.h265";
1185 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1186 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1187 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1188 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1189 vEncSample->WaitForEOS();
1190 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1191 }
1192 }
1193
1194 /**
1195 * @tc.number : RESET_QP_014
1196 * @tc.name : reset QP in VBR mode, use setparameter h265
1197 * @tc.desc : function test
1198 */
1199 HWTEST_F(HwEncSetParamNdkTest, RESET_QP_014, TestSize.Level1)
1200 {
1201 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1202 auto vEncSample = make_unique<VEncAPI11Sample>();
1203 vEncSample->INP_DIR = INP_DIR_720;
1204 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1205 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1206 vEncSample->DEFAULT_FRAME_RATE = 10;
1207 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1208 vEncSample->enableAutoSwitchParam = true;
1209 vEncSample->needResetQP = true;
1210 vEncSample->switchParamsTimeSec = 1;
1211 vEncSample->OUT_DIR = "/data/test/media/vbr_qp_.h265";
1212 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1213 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1214 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1215 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1216 vEncSample->WaitForEOS();
1217 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1218 }
1219 }
1220
1221 /**
1222 * @tc.number : SET_PROFILE_001
1223 * @tc.name : set profile main
1224 * @tc.desc : function test
1225 */
1226 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_001, TestSize.Level1)
1227 {
1228 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1229 auto vEncSample = make_unique<VEncAPI11Sample>();
1230 vEncSample->INP_DIR = INP_DIR_720;
1231 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1232 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1233 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1234 vEncSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN;
1235 vEncSample->OUT_DIR = "/data/test/media/pq_vivid.h265";
1236 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1237 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1238 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1239 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1240 vEncSample->WaitForEOS();
1241 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1242 }
1243 }
1244 /**
1245 * @tc.number : SET_PROFILE_002
1246 * @tc.name : set profile main10
1247 * @tc.desc : function test
1248 */
1249 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_002, TestSize.Level1)
1250 {
1251 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1252 auto vEncSample = make_unique<VEncAPI11Sample>();
1253 vEncSample->INP_DIR = INP_DIR_720;
1254 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1255 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1256 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1257 vEncSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN_10;
1258 vEncSample->OUT_DIR = "/data/test/media/pq_vivid.h265";
1259 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1260 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1261 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1262 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1263 vEncSample->WaitForEOS();
1264 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1265 }
1266 }
1267 /**
1268 * @tc.number : SET_PROFILE_003
1269 * @tc.name : set profile high
1270 * @tc.desc : function test
1271 */
1272 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_003, TestSize.Level1)
1273 {
1274 if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1275 auto vEncSample = make_unique<VEncAPI11Sample>();
1276 vEncSample->INP_DIR = INP_DIR_720;
1277 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1278 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1279 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1280 vEncSample->DEFAULT_PROFILE = AVC_PROFILE_HIGH;
1281 vEncSample->OUT_DIR = "/data/test/media/1280_720_30_10Mb.h264";
1282 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1283 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1284 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1285 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1286 vEncSample->WaitForEOS();
1287 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1288 }
1289 }
1290 /**
1291 * @tc.number : SET_PROFILE_004
1292 * @tc.name : set profile main
1293 * @tc.desc : function test
1294 */
1295 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_004, TestSize.Level1)
1296 {
1297 if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1298 auto vEncSample = make_unique<VEncAPI11Sample>();
1299 vEncSample->INP_DIR = INP_DIR_720;
1300 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1301 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1302 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1303 vEncSample->DEFAULT_PROFILE = AVC_PROFILE_MAIN;
1304 vEncSample->OUT_DIR = "/data/test/media/1280_720_30_10Mb.h264";
1305 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1306 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1307 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1308 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1309 vEncSample->WaitForEOS();
1310 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1311 }
1312 }
1313 /**
1314 * @tc.number : SET_PROFILE_005
1315 * @tc.name : set profile main
1316 * @tc.desc : function test
1317 */
1318 HWTEST_F(HwEncSetParamNdkTest, SET_PROFILE_005, TestSize.Level1)
1319 {
1320 if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1321 auto vEncSample = make_unique<VEncAPI11Sample>();
1322 vEncSample->INP_DIR = INP_DIR_720;
1323 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1324 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1325 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1326 vEncSample->DEFAULT_PROFILE = AVC_PROFILE_BASELINE;
1327 vEncSample->OUT_DIR = "/data/test/media/1280_720_30_10Mb.h264";
1328 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1329 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1330 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1331 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1332 vEncSample->WaitForEOS();
1333 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1334 }
1335 }
1336 /**
1337 * @tc.number : SET_RANGE_FLAG_001
1338 * @tc.name : set range flag true HEVC
1339 * @tc.desc : function test
1340 */
1341 HWTEST_F(HwEncSetParamNdkTest, SET_RANGE_FLAG_001, TestSize.Level1)
1342 {
1343 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1344 auto vEncSample = make_unique<VEncAPI11Sample>();
1345 vEncSample->INP_DIR = INP_DIR_720;
1346 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1347 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1348 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1349 vEncSample->DEFAULT_RANGE_FLAG = 1;
1350 vEncSample->OUT_DIR = "/data/test/media/vbr_fullrange.h265";
1351 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1352 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1353 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1354 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1355 vEncSample->WaitForEOS();
1356 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1357 }
1358 }
1359
1360 /**
1361 * @tc.number : SET_RANGE_FLAG_002
1362 * @tc.name : set range flag true
1363 * @tc.desc : function test
1364 */
1365 HWTEST_F(HwEncSetParamNdkTest, SET_RANGE_FLAG_002, TestSize.Level1)
1366 {
1367 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1368 auto vEncSample = make_unique<VEncAPI11Sample>();
1369 vEncSample->INP_DIR = INP_DIR_720;
1370 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1371 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1372 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1373 vEncSample->DEFAULT_RANGE_FLAG = 1;
1374 vEncSample->OUT_DIR = "/data/test/media/vbr_fullrange.h264";
1375 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1376 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1377 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1378 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1379 vEncSample->WaitForEOS();
1380 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1381 }
1382 }
1383
1384 /**
1385 * @tc.number : SET_COLORSPACE_001
1386 * @tc.name : set color space parameter
1387 * @tc.desc : function test
1388 */
1389 HWTEST_F(HwEncSetParamNdkTest, SET_COLORSPACE_001, TestSize.Level1)
1390 {
1391 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1392 auto vEncSample = make_unique<VEncAPI11Sample>();
1393 vEncSample->INP_DIR = INP_DIR_720;
1394 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1395 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1396 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1397 vEncSample->DEFAULT_RANGE_FLAG = 1;
1398 vEncSample->enableColorSpaceParams = true;
1399 vEncSample->OUT_DIR = "/data/test/media/vbr_cs.h264";
1400 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1401 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1402 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1403 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1404 vEncSample->WaitForEOS();
1405 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1406 }
1407 }
1408
1409 /**
1410 * @tc.number : SET_COLORSPACE_002
1411 * @tc.name : set color space parameter HEVC
1412 * @tc.desc : function test
1413 */
1414 HWTEST_F(HwEncSetParamNdkTest, SET_COLORSPACE_002, TestSize.Level1)
1415 {
1416 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1417 auto vEncSample = make_unique<VEncAPI11Sample>();
1418 vEncSample->INP_DIR = INP_DIR_720;
1419 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1420 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1421 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1422 vEncSample->DEFAULT_RANGE_FLAG = 1;
1423 vEncSample->enableColorSpaceParams = true;
1424 vEncSample->OUT_DIR = "/data/test/media/vbr_cs.h265";
1425 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1426 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1427 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1428 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1429 vEncSample->WaitForEOS();
1430 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1431 }
1432 }
1433
1434 /**
1435 * @tc.number : SET_FORCE_IDR_001
1436 * @tc.name : request i frame HEVC
1437 * @tc.desc : function test
1438 */
1439 HWTEST_F(HwEncSetParamNdkTest, SET_FORCE_IDR_001, TestSize.Level1)
1440 {
1441 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1442 auto vEncSample = make_unique<VEncAPI11Sample>();
1443 vEncSample->INP_DIR = INP_DIR_720;
1444 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1445 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1446 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1447 vEncSample->DEFAULT_RANGE_FLAG = 1;
1448 vEncSample->enableForceIDR = true;
1449 vEncSample->OUT_DIR = "/data/test/media/vbr_i.h265";
1450 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1451 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1452 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1453 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1454 vEncSample->WaitForEOS();
1455 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1456 }
1457 }
1458
1459 /**
1460 * @tc.number : SET_FORCE_IDR_002
1461 * @tc.name : request i frame
1462 * @tc.desc : function test
1463 */
1464 HWTEST_F(HwEncSetParamNdkTest, SET_FORCE_IDR_002, TestSize.Level1)
1465 {
1466 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1467 auto vEncSample = make_unique<VEncAPI11Sample>();
1468 vEncSample->INP_DIR = INP_DIR_720;
1469 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1470 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1471 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1472 vEncSample->DEFAULT_RANGE_FLAG = 1;
1473 vEncSample->enableForceIDR = true;
1474 vEncSample->OUT_DIR = "/data/test/media/vbr_i.h264";
1475 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1476 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1477 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1478 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1479 vEncSample->WaitForEOS();
1480 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1481 }
1482 }
1483 /**
1484 * @tc.number : COLORSPACE_CONFIG_001
1485 * @tc.name : COLORSPACE
1486 * @tc.desc : function test
1487 */
1488 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_001, TestSize.Level1)
1489 {
1490 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1491 if (cap) {
1492 auto vEncSample = make_unique<VEncAPI11Sample>();
1493 vEncSample->INP_DIR = INP_DIR_720;
1494 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1495 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1496 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1497 vEncSample->DEFAULT_RANGE_FLAG = 1;
1498 vEncSample->enableColorSpaceParams = true;
1499 vEncSample->DEFAULT_COLOR_PRIMARIES = 100;
1500 vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = 10000;
1501 vEncSample->DEFAULT_MATRIX_COEFFICIENTS = 10000;
1502 vEncSample->OUT_DIR = "/data/test/media/vbr_i.h264";
1503 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1504 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1505 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
1506 ASSERT_EQ(AV_ERR_INVALID_STATE, vEncSample->StartVideoEncoder());
1507 vEncSample->WaitForEOS();
1508 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1509 } else {
1510 return;
1511 }
1512 }
1513
1514 /**
1515 * @tc.number : COLORSPACE_CONFIG_002
1516 * @tc.name : COLORSPACE 264
1517 * @tc.desc : function test
1518 */
1519 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_002, TestSize.Level1)
1520 {
1521 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
1522 if (cap) {
1523 auto vEncSample = make_unique<VEncAPI11Sample>();
1524 vEncSample->INP_DIR = INP_DIR_720;
1525 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1526 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1527 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1528 vEncSample->DEFAULT_RANGE_FLAG = 1;
1529 vEncSample->enableColorSpaceParams = true;
1530 vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT709;
1531 vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_BT709;
1532 vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT709;
1533 vEncSample->OUT_DIR = "/data/test/media/bt_709_h264.h264";
1534 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1535 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1536 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1537 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1538 vEncSample->WaitForEOS();
1539 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1540 } else {
1541 return;
1542 }
1543 }
1544
1545 /**
1546 * @tc.number : COLORSPACE_CONFIG_003
1547 * @tc.name : COLORSPACE 265
1548 * @tc.desc : function test
1549 */
1550 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_003, TestSize.Level1)
1551 {
1552 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1553 if (cap) {
1554 auto vEncSample = make_unique<VEncAPI11Sample>();
1555 vEncSample->INP_DIR = INP_DIR_720;
1556 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1557 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1558 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1559 vEncSample->DEFAULT_RANGE_FLAG = 1;
1560 vEncSample->enableColorSpaceParams = true;
1561 vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT709;
1562 vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_BT709;
1563 vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT709;
1564 vEncSample->OUT_DIR = "/data/test/media/bt_709_h265.h265";
1565 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1566 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1567 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1568 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1569 vEncSample->WaitForEOS();
1570 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1571 } else {
1572 return;
1573 }
1574 }
1575
1576 /**
1577 * @tc.number : COLORSPACE_CONFIG_004
1578 * @tc.name : COLORSPACE 265
1579 * @tc.desc : function test
1580 */
1581 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_004, TestSize.Level1)
1582 {
1583 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1584 if (cap) {
1585 auto vEncSample = make_unique<VEncAPI11Sample>();
1586 vEncSample->INP_DIR = INP_DIR_720;
1587 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1588 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1589 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1590 vEncSample->DEFAULT_RANGE_FLAG = 0;
1591 vEncSample->enableColorSpaceParams = true;
1592 vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT2020;
1593 vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_PQ;
1594 vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT2020_NCL;
1595 vEncSample->OUT_DIR = "/data/test/media/bt_2020_PQ_h265.h265";
1596 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1597 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1598 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1599 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1600 vEncSample->WaitForEOS();
1601 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1602 } else {
1603 return;
1604 }
1605 }
1606
1607 /**
1608 * @tc.number : COLORSPACE_CONFIG_005
1609 * @tc.name : COLORSPACE 265
1610 * @tc.desc : function test
1611 */
1612 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_005, TestSize.Level1)
1613 {
1614 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1615 if (cap) {
1616 auto vEncSample = make_unique<VEncAPI11Sample>();
1617 vEncSample->INP_DIR = INP_DIR_720;
1618 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1619 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1620 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1621 vEncSample->DEFAULT_RANGE_FLAG = 0;
1622 vEncSample->enableColorSpaceParams = true;
1623 vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_BT2020;
1624 vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_HLG;
1625 vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT2020_NCL;
1626 vEncSample->OUT_DIR = "/data/test/media/bt_2020_HLG_h265.h265";
1627 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1628 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1629 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1630 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1631 vEncSample->WaitForEOS();
1632 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1633 } else {
1634 return;
1635 }
1636 }
1637
1638 /**
1639 * @tc.number : COLORSPACE_CONFIG_006
1640 * @tc.name : COLORSPACE 265
1641 * @tc.desc : function test
1642 */
1643 HWTEST_F(HwEncSetParamNdkTest, COLORSPACE_CONFIG_006, TestSize.Level1)
1644 {
1645 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
1646 if (cap) {
1647 auto vEncSample = make_unique<VEncAPI11Sample>();
1648 vEncSample->INP_DIR = INP_DIR_720;
1649 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1650 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1651 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1652 vEncSample->DEFAULT_RANGE_FLAG = 0;
1653 vEncSample->enableColorSpaceParams = true;
1654 vEncSample->DEFAULT_COLOR_PRIMARIES = COLOR_PRIMARY_P3D65;
1655 vEncSample->DEFAULT_TRANSFER_CHARACTERISTICS = TRANSFER_CHARACTERISTIC_PQ;
1656 vEncSample->DEFAULT_MATRIX_COEFFICIENTS = MATRIX_COEFFICIENT_BT2020_NCL;
1657 vEncSample->OUT_DIR = "/data/test/media/bt_2020_P3D65_h265.h265";
1658 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1659 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1660 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1661 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1662 vEncSample->WaitForEOS();
1663 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1664 } else {
1665 return;
1666 }
1667 }
1668
1669 /**
1670 * @tc.number : FRAMENUM_JUDGMENT_001
1671 * @tc.name : Increase frame rate judgment
1672 * @tc.desc : function test
1673 */
1674 HWTEST_F(HwEncSetParamNdkTest, FRAMENUM_JUDGMENT_001, TestSize.Level0)
1675 {
1676 if (!strcmp(g_codecName, "OMX.hisi.video.encoder.avc")) {
1677 auto vEncSample = make_unique<VEncAPI11Sample>();
1678 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_CQ);
1679 if (isSupported) {
1680 vEncSample->INP_DIR = INP_DIR_720;
1681 vEncSample->OUT_DIR = "/data/test/media/1280_720_nv.h264";
1682 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1683 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1684 vEncSample->DEFAULT_FRAME_RATE = 30;
1685 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1686 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1687 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1688 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1689 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1690 vEncSample->WaitForEOS();
1691 ASSERT_EQ(25, vEncSample->outCount);
1692 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1693 }
1694 }
1695 }
1696 /**
1697 * @tc.number : FRAMENUM_JUDGMENT_002
1698 * @tc.name : Increase frame rate judgment
1699 * @tc.desc : function test
1700 */
1701 HWTEST_F(HwEncSetParamNdkTest, FRAMENUM_JUDGMENT_002, TestSize.Level0)
1702 {
1703 if (!strcmp(g_codecNameHEVC, "OMX.hisi.video.encoder.hevc")) {
1704 auto vEncSample = make_unique<VEncAPI11Sample>();
1705 vEncSample->INP_DIR = INP_DIR_720;
1706 vEncSample->OUT_DIR = "/data/test/media/EN_1280_720_nv.h265";
1707 vEncSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1708 vEncSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1709 vEncSample->DEFAULT_FRAME_RATE = 30;
1710 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1711 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1712 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1713 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1714 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1715 vEncSample->WaitForEOS();
1716 ASSERT_EQ(25, vEncSample->outCount);
1717 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1718 }
1719 }
1720 }
1721