1 /*
2 * Copyright (C) 2025 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 <iostream>
16 #include <cstdio>
17 #include <string>
18
19 #include "gtest/gtest.h"
20 #include "native_avcodec_base.h"
21 #include "native_avformat.h"
22 #include "native_avcodec_videoencoder.h"
23 #include "VideoencApi11Sample.h"
24 #include "native_avcapability.h"
25 using namespace std;
26 using namespace OHOS;
27 using namespace OHOS::Media;
28 using namespace testing::ext;
29 namespace {
30 OH_AVCodec *gVenc = nullptr;
31 OH_AVCapability* gCap = nullptr;
32 OH_AVCapability* g_capEnc = nullptr;
33 const char* CODEC_NAME = "";
34 const char* OUT_DIR = "/data/test/media/videoEncodeFileRoi.h265";
35 } // namespace
36
37 namespace OHOS {
38 namespace Media {
39 class HwEncFuncSqrTest : public testing::Test {
40 public:
41 // SetUpTestCase: Called before all test cases
42 static void SetUpTestCase(void);
43 // TearDownTestCase: Called after all test case
44 static void TearDownTestCase(void);
45 // SetUp: Called before each test cases
46 void SetUp(void);
47 // TearDown: Called after each test cases
48 void TearDown(void);
49
50 protected:
51 const char* INP_DIR_1080_30 = "/data/test/media/1080_1920_nv12.yuv";
52 };
53
SetUpTestCase()54 void HwEncFuncSqrTest::SetUpTestCase()
55 {
56 g_capEnc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
57 CODEC_NAME = OH_AVCapability_GetName(g_capEnc);
58 cout << "codecname: " << CODEC_NAME << endl;
59 }
TearDownTestCase()60 void HwEncFuncSqrTest::TearDownTestCase() {}
SetUp()61 void HwEncFuncSqrTest::SetUp() {}
TearDown()62 void HwEncFuncSqrTest::TearDown()
63 {
64 if (gVenc != nullptr) {
65 OH_VideoEncoder_Destroy(gVenc);
66 gVenc = nullptr;
67 }
68 }
69 } // namespace Media
70 } // namespace OHOS
71
72 namespace {
73 /**
74 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_001
75 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_001
76 * @tc.desc : function test
77 */
78 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_001, TestSize.Level1)
79 {
80 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
81 if (!isSupported) {
82 return;
83 }
84 auto vEncSample = make_unique<VEncAPI11Sample>();
85 vEncSample->DEFAULT_WIDTH = 1080;
86 vEncSample->DEFAULT_HEIGHT = 1920;
87 vEncSample->OUT_DIR = OUT_DIR;
88 vEncSample->SETBIRATE = true;
89 vEncSample->FACTOR_ENABLE = true;
90 vEncSample->MAXBITE_ENABLE = true;
91 vEncSample->MODE_ENABLE = true;
92 vEncSample->SURF_INPUT = true;
93 vEncSample->DEFAULT_BITRATE_MODE = VBR;
94 vEncSample->DEFAULT_BITRATE = 20000000;
95 vEncSample->DEFAULT_MAX_BITRATE = 20000000;
96 vEncSample->DEFAULT_SQR_FACTOR = 32;
97 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
98 vEncSample->INP_DIR = INP_DIR_1080_30;
99 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
100 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
101 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
102 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
103 vEncSample->WaitForEOS();
104 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
105 }
106
107 /**
108 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_002
109 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_002
110 * @tc.desc : function test
111 */
112 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_002, TestSize.Level1)
113 {
114 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
115 if (!isSupported) {
116 return;
117 }
118 auto vEncSample = make_unique<VEncAPI11Sample>();
119 vEncSample->DEFAULT_WIDTH = 1080;
120 vEncSample->DEFAULT_HEIGHT = 1920;
121 vEncSample->OUT_DIR = OUT_DIR;
122 vEncSample->SETBIRATE = true;
123 vEncSample->FACTOR_ENABLE = true;
124 vEncSample->MAXBITE_ENABLE = true;
125 vEncSample->SURF_INPUT = true;
126 vEncSample->DEFAULT_BITRATE = 20000000;
127 vEncSample->DEFAULT_MAX_BITRATE = 20000000;
128 vEncSample->DEFAULT_SQR_FACTOR = 32;
129 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
130 vEncSample->INP_DIR = INP_DIR_1080_30;
131 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
132 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
133 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
134 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
135 vEncSample->WaitForEOS();
136 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
137 }
138
139 /**
140 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_003
141 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_003
142 * @tc.desc : function test
143 */
144 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_003, TestSize.Level1)
145 {
146 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
147 if (!isSupported) {
148 return;
149 }
150 auto vEncSample = make_unique<VEncAPI11Sample>();
151 vEncSample->DEFAULT_WIDTH = 1080;
152 vEncSample->DEFAULT_HEIGHT = 1920;
153 vEncSample->OUT_DIR = OUT_DIR;
154 vEncSample->FACTOR_ENABLE = true;
155 vEncSample->MAXBITE_ENABLE = true;
156 vEncSample->MODE_ENABLE = true;
157 vEncSample->SURF_INPUT = true;
158 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
159 vEncSample->DEFAULT_SQR_FACTOR = 32;
160 vEncSample->DEFAULT_BITRATE_MODE = SQR;
161 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
162 vEncSample->INP_DIR = INP_DIR_1080_30;
163 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
164 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
165 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
166 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
167 vEncSample->WaitForEOS();
168 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
169 }
170
171 /**
172 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_004
173 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_004
174 * @tc.desc : function test
175 */
176 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_004, TestSize.Level1)
177 {
178 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
179 if (!isSupported) {
180 return;
181 }
182 auto vEncSample = make_unique<VEncAPI11Sample>();
183 vEncSample->DEFAULT_WIDTH = 1080;
184 vEncSample->DEFAULT_HEIGHT = 1920;
185 vEncSample->OUT_DIR = OUT_DIR;
186 vEncSample->MODE_ENABLE = true;
187 vEncSample->SURF_INPUT = true;
188 vEncSample->DEFAULT_BITRATE_MODE = SQR;
189 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
190 vEncSample->INP_DIR = INP_DIR_1080_30;
191 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
192 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
193 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
194 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
195 vEncSample->WaitForEOS();
196 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
197 }
198
199 /**
200 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_005
201 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_005
202 * @tc.desc : function test
203 */
204 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_005, TestSize.Level1)
205 {
206 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
207 if (!isSupported) {
208 return;
209 }
210 auto vEncSample = make_unique<VEncAPI11Sample>();
211 vEncSample->DEFAULT_WIDTH = 1080;
212 vEncSample->DEFAULT_HEIGHT = 1920;
213 vEncSample->OUT_DIR = OUT_DIR;
214 vEncSample->SETBIRATE = true;
215 vEncSample->FACTOR_ENABLE = true;
216 vEncSample->SURF_INPUT = true;
217 vEncSample->MODE_ENABLE = true;
218 vEncSample->DEFAULT_BITRATE = 10000000;
219 vEncSample->DEFAULT_SQR_FACTOR = 32;
220 vEncSample->DEFAULT_BITRATE_MODE = SQR;
221 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
222 vEncSample->INP_DIR = INP_DIR_1080_30;
223 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
224 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
225 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
226 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
227 vEncSample->WaitForEOS();
228 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
229 }
230
231 /**
232 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_006
233 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_006
234 * @tc.desc : function test
235 */
236 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_006, TestSize.Level1)
237 {
238 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
239 if (!isSupported) {
240 return;
241 }
242 auto vEncSample = make_unique<VEncAPI11Sample>();
243 vEncSample->DEFAULT_WIDTH = 1080;
244 vEncSample->DEFAULT_HEIGHT = 1920;
245 vEncSample->OUT_DIR = OUT_DIR;
246 vEncSample->SETBIRATE = true;
247 vEncSample->SURF_INPUT = true;
248 vEncSample->MODE_ENABLE = true;
249 vEncSample->DEFAULT_BITRATE = 10000000;
250 vEncSample->DEFAULT_BITRATE_MODE = SQR;
251 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
252 vEncSample->INP_DIR = INP_DIR_1080_30;
253 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
254 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
255 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
256 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
257 vEncSample->WaitForEOS();
258 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
259 }
260
261 /**
262 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_007
263 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_007
264 * @tc.desc : function test
265 */
266 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_007, TestSize.Level1)
267 {
268 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
269 if (!isSupported) {
270 return;
271 }
272 auto vEncSample = make_unique<VEncAPI11Sample>();
273 vEncSample->DEFAULT_WIDTH = 1080;
274 vEncSample->DEFAULT_HEIGHT = 1920;
275 vEncSample->OUT_DIR = OUT_DIR;
276 vEncSample->SETBIRATE = true;
277 vEncSample->SURF_INPUT = true;
278 vEncSample->MODE_ENABLE = true;
279 vEncSample->MAXBITE_ENABLE = true;
280 vEncSample->DEFAULT_BITRATE = 10000000;
281 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
282 vEncSample->DEFAULT_BITRATE_MODE = SQR;
283 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
284 vEncSample->INP_DIR = INP_DIR_1080_30;
285 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
286 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
287 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
288 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
289 vEncSample->WaitForEOS();
290 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
291 }
292
293 /**
294 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_008
295 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_008
296 * @tc.desc : function test
297 */
298 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_008, TestSize.Level1)
299 {
300 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
301 if (!isSupported) {
302 return;
303 }
304 auto vEncSample = make_unique<VEncAPI11Sample>();
305 vEncSample->DEFAULT_WIDTH = 1080;
306 vEncSample->DEFAULT_HEIGHT = 1920;
307 vEncSample->OUT_DIR = OUT_DIR;
308 vEncSample->SETBIRATE = true;
309 vEncSample->SURF_INPUT = true;
310 vEncSample->MODE_ENABLE = true;
311 vEncSample->MAXBITE_ENABLE = true;
312 vEncSample->FACTOR_ENABLE = true;
313 vEncSample->DEFAULT_BITRATE = 10000000;
314 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
315 vEncSample->DEFAULT_SQR_FACTOR = 100;
316 vEncSample->DEFAULT_BITRATE_MODE = SQR;
317 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
318 vEncSample->INP_DIR = INP_DIR_1080_30;
319 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
320 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
321 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
322 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
323 vEncSample->WaitForEOS();
324 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
325 }
326
327 /**
328 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_009
329 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_009
330 * @tc.desc : function test
331 */
332 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_009, TestSize.Level1)
333 {
334 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
335 if (!isSupported) {
336 return;
337 }
338 auto vEncSample = make_unique<VEncAPI11Sample>();
339 vEncSample->DEFAULT_WIDTH = 1080;
340 vEncSample->DEFAULT_HEIGHT = 1920;
341 vEncSample->OUT_DIR = OUT_DIR;
342 vEncSample->SETBIRATE = true;
343 vEncSample->SURF_INPUT = true;
344 vEncSample->MODE_ENABLE = true;
345 vEncSample->MAXBITE_ENABLE = true;
346 vEncSample->FACTOR_ENABLE = true;
347 vEncSample->QUALITY_ENABLE = true;
348 vEncSample->DEFAULT_BITRATE = 10000000;
349 vEncSample->DEFAULT_MAX_BITRATE = 150000000;
350 vEncSample->DEFAULT_SQR_FACTOR = 32;
351 vEncSample->DEFAULT_QUALITY = 28;
352 vEncSample->DEFAULT_BITRATE_MODE = SQR;
353 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
354 vEncSample->INP_DIR = INP_DIR_1080_30;
355 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
356 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
357 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
358 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
359 vEncSample->WaitForEOS();
360 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
361 }
362
363 /**
364 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_010
365 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_010
366 * @tc.desc : function test
367 */
368 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_010, TestSize.Level1)
369 {
370 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
371 if (!isSupported) {
372 return;
373 }
374 gCap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
375 const char *codecNameAvc = OH_AVCapability_GetName(gCap);
376 cout << "codecNameAvc: " << codecNameAvc << endl;
377 auto vEncSample = make_unique<VEncAPI11Sample>();
378 vEncSample->DEFAULT_WIDTH = 1080;
379 vEncSample->DEFAULT_HEIGHT = 1920;
380 vEncSample->OUT_DIR = OUT_DIR;
381 vEncSample->SURF_INPUT = true;
382 vEncSample->MODE_ENABLE = true;
383 vEncSample->MAXBITE_ENABLE = true;
384 vEncSample->FACTOR_ENABLE = true;
385 vEncSample->DEFAULT_MAX_BITRATE = 50000000;
386 vEncSample->DEFAULT_SQR_FACTOR = 30;
387 vEncSample->DEFAULT_BITRATE_MODE = SQR;
388 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
389 vEncSample->INP_DIR = INP_DIR_1080_30;
390 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameAvc));
391 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
392 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
393 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
394 vEncSample->WaitForEOS();
395 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
396 }
397
398 /**
399 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_011
400 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_011
401 * @tc.desc : function test
402 */
403 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_011, TestSize.Level1)
404 {
405 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
406 if (!isSupported) {
407 return;
408 }
409 auto vEncSample = make_unique<VEncAPI11Sample>();
410 vEncSample->DEFAULT_WIDTH = 1080;
411 vEncSample->DEFAULT_HEIGHT = 1920;
412 vEncSample->OUT_DIR = OUT_DIR;
413 vEncSample->FACTOR_ENABLE = true;
414 vEncSample->MAXBITE_ENABLE = true;
415 vEncSample->MODE_ENABLE = true;
416 vEncSample->SURF_INPUT = true;
417 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
418 vEncSample->DEFAULT_SQR_FACTOR = 32;
419 vEncSample->DEFAULT_BITRATE_MODE = SQR;
420 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
421 vEncSample->INP_DIR = INP_DIR_1080_30;
422 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
423 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
424 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
425 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
426 vEncSample->WaitForEOS();
427 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
428 }
429
430 /**
431 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_012
432 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_012
433 * @tc.desc : function test
434 */
435 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_012, TestSize.Level1)
436 {
437 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
438 if (!isSupported) {
439 return;
440 }
441 auto vEncSample = make_unique<VEncAPI11Sample>();
442 vEncSample->DEFAULT_WIDTH = 1080;
443 vEncSample->DEFAULT_HEIGHT = 1920;
444 vEncSample->OUT_DIR = OUT_DIR;
445 vEncSample->MODE_ENABLE = true;
446 vEncSample->SURF_INPUT = true;
447 vEncSample->DEFAULT_BITRATE_MODE = SQR;
448 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
449 vEncSample->INP_DIR = INP_DIR_1080_30;
450 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
451 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
452 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
453 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
454 vEncSample->WaitForEOS();
455 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
456 }
457
458 /**
459 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_013
460 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_013
461 * @tc.desc : function test
462 */
463 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_013, TestSize.Level1)
464 {
465 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
466 if (!isSupported) {
467 return;
468 }
469 auto vEncSample = make_unique<VEncAPI11Sample>();
470 vEncSample->DEFAULT_WIDTH = 1080;
471 vEncSample->DEFAULT_HEIGHT = 1920;
472 vEncSample->OUT_DIR = OUT_DIR;
473 vEncSample->SETBIRATE = true;
474 vEncSample->FACTOR_ENABLE = true;
475 vEncSample->SURF_INPUT = true;
476 vEncSample->MODE_ENABLE = true;
477 vEncSample->DEFAULT_BITRATE = 10000000;
478 vEncSample->DEFAULT_SQR_FACTOR = 32;
479 vEncSample->DEFAULT_BITRATE_MODE = SQR;
480 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
481 vEncSample->INP_DIR = INP_DIR_1080_30;
482 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
483 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
484 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
485 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
486 vEncSample->WaitForEOS();
487 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
488 }
489
490 /**
491 * @tc.number : VIDEO_HW_ENCODE_SQR_FUNC_014
492 * @tc.name : VIDEO_HW_ENCODE_SQR_FUNC_014
493 * @tc.desc : function test
494 */
495 HWTEST_F(HwEncFuncSqrTest, VIDEO_HW_ENCODE_SQR_FUNC_014, TestSize.Level1)
496 {
497 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
498 if (!isSupported) {
499 return;
500 }
501 auto vEncSample = make_unique<VEncAPI11Sample>();
502 vEncSample->DEFAULT_WIDTH = 1080;
503 vEncSample->DEFAULT_HEIGHT = 1920;
504 vEncSample->OUT_DIR = OUT_DIR;
505 vEncSample->SETBIRATE = true;
506 vEncSample->SURF_INPUT = true;
507 vEncSample->MODE_ENABLE = true;
508 vEncSample->DEFAULT_BITRATE = 10000000;
509 vEncSample->DEFAULT_BITRATE_MODE = SQR;
510 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
511 vEncSample->INP_DIR = INP_DIR_1080_30;
512 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
513 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
514 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
515 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
516 vEncSample->WaitForEOS();
517 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
518 }
519 } // namespace