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 const char* CODEC_NAME = "";
32 OH_AVCapability* g_capEnc = nullptr;
33 OH_AVFormat* gFormat = nullptr;
34 } // namespace
35
36 namespace OHOS {
37 namespace Media {
38 class HwEncSqrFuncTest : public testing::Test {
39 public:
40 // SetUpTestCase: Called before all test cases
41 static void SetUpTestCase(void);
42 // TearDownTestCase: Called after all test case
43 static void TearDownTestCase(void);
44 // SetUp: Called before each test cases
45 void SetUp(void);
46 // TearDown: Called after each test cases
47 void TearDown(void);
48
49 protected:
50 const char *INP_DIR_1080_30 = "/data/test/media/1080_1920_nv12.yuv";
51 };
52
SetUpTestCase()53 void HwEncSqrFuncTest::SetUpTestCase()
54 {
55 g_capEnc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
56 CODEC_NAME = OH_AVCapability_GetName(g_capEnc);
57 cout << "g_codecname: " << CODEC_NAME << endl;
58 }
TearDownTestCase()59 void HwEncSqrFuncTest::TearDownTestCase() {}
SetUp()60 void HwEncSqrFuncTest::SetUp() {}
TearDown()61 void HwEncSqrFuncTest::TearDown()
62 {
63 if (gVenc != NULL) {
64 OH_VideoEncoder_Destroy(gVenc);
65 gVenc = nullptr;
66 }
67 if (gFormat != nullptr) {
68 OH_AVFormat_Destroy(gFormat);
69 gFormat = nullptr;
70 }
71 }
72 } // namespace Media
73 } // namespace OHOS
74
75 namespace {
76 /**
77 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_001
78 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_001
79 * @tc.desc : function test
80 */
81 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_001, TestSize.Level2)
82 {
83 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
84 if (!isSupported)
85 {
86 return;
87 }
88 auto vEncSample = make_unique<VEncAPI11Sample>();
89 vEncSample->DEFAULT_WIDTH = 1080;
90 vEncSample->DEFAULT_HEIGHT = 1920;
91 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case01.h265";
92 vEncSample->FACTOR_ENABLE = true;
93 vEncSample->MAXBITE_ENABLE = true;
94 vEncSample->MODE_ENABLE = true;
95 vEncSample->enableParameter = true;
96 vEncSample->MAXBITE_ENABLE_RUN = true;
97 vEncSample->FACTOR_ENABLE_RUN = true;
98 vEncSample->DEFAULT_BITRATE_MODE = SQR;
99 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
100 vEncSample->DEFAULT_SQR_FACTOR = 32;
101 vEncSample->DEFAULT_MAX_BITRATE_RUN = 1000000;
102 vEncSample->DEFAULT_SQR_FACTOR_RUN = 51;
103 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
104 vEncSample->INP_DIR = INP_DIR_1080_30;
105 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
106 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
107 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
108 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
109 vEncSample->WaitForEOS();
110 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
111 }
112
113 /**
114 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_002
115 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_002
116 * @tc.desc : function test
117 */
118 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_002, TestSize.Level2)
119 {
120 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
121 if (!isSupported) {
122 return;
123 }
124 auto vEncSample = make_unique<VEncAPI11Sample>();
125 vEncSample->DEFAULT_WIDTH = 1080;
126 vEncSample->DEFAULT_HEIGHT = 1920;
127 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case02.h265";
128 vEncSample->FACTOR_ENABLE = true;
129 vEncSample->MAXBITE_ENABLE = true;
130 vEncSample->MODE_ENABLE = true;
131 vEncSample->enableParameter = true;
132 vEncSample->MAXBITE_ENABLE_RUN = true;
133 vEncSample->FACTOR_ENABLE_RUN = true;
134 vEncSample->DEFAULT_BITRATE_MODE = SQR;
135 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
136 vEncSample->DEFAULT_SQR_FACTOR = 32;
137 vEncSample->DEFAULT_MAX_BITRATE_RUN = 1000000;
138 vEncSample->DEFAULT_SQR_FACTOR_RUN = 51;
139 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
140 vEncSample->INP_DIR = INP_DIR_1080_30;
141 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
142 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
143 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
144 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
145 vEncSample->WaitForEOS();
146 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
147 }
148
149 /**
150 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_003
151 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_003
152 * @tc.desc : function test
153 */
154 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_003, TestSize.Level2)
155 {
156 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
157 if (!isSupported) {
158 return;
159 }
160 auto vEncSample = make_unique<VEncAPI11Sample>();
161 vEncSample->DEFAULT_WIDTH = 1080;
162 vEncSample->DEFAULT_HEIGHT = 1920;
163 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case03.h265";
164 vEncSample->FACTOR_ENABLE = true;
165 vEncSample->MAXBITE_ENABLE = true;
166 vEncSample->MODE_ENABLE = true;
167 vEncSample->enableParameter = true;
168 vEncSample->FACTOR_ENABLE_RUN = true;
169 vEncSample->DEFAULT_BITRATE_MODE = SQR;
170 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
171 vEncSample->DEFAULT_SQR_FACTOR = 32;
172 vEncSample->DEFAULT_SQR_FACTOR_RUN = 51;
173 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
174 vEncSample->INP_DIR = INP_DIR_1080_30;
175 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
176 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
177 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
178 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
179 vEncSample->WaitForEOS();
180 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
181 }
182
183 /**
184 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_004
185 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_004
186 * @tc.desc : function test
187 */
188 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_004, TestSize.Level2)
189 {
190 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
191 if (!isSupported) {
192 return;
193 }
194 auto vEncSample = make_unique<VEncAPI11Sample>();
195 vEncSample->DEFAULT_WIDTH = 1080;
196 vEncSample->DEFAULT_HEIGHT = 1920;
197 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case04.h265";
198 vEncSample->FACTOR_ENABLE = true;
199 vEncSample->MAXBITE_ENABLE = true;
200 vEncSample->MODE_ENABLE = true;
201 vEncSample->enableParameter = true;
202 vEncSample->MAXBITE_ENABLE_RUN = true;
203 vEncSample->DEFAULT_BITRATE_MODE = SQR;
204 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
205 vEncSample->DEFAULT_SQR_FACTOR = 32;
206 vEncSample->DEFAULT_MAX_BITRATE_RUN = 1000000;
207 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
208 vEncSample->INP_DIR = INP_DIR_1080_30;
209 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
210 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
211 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
212 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
213 vEncSample->WaitForEOS();
214 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
215 }
216
217 /**
218 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_005
219 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_005
220 * @tc.desc : function test
221 */
222 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_005, TestSize.Level2)
223 {
224 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
225 if (!isSupported) {
226 return;
227 }
228 auto vEncSample = make_unique<VEncAPI11Sample>();
229 vEncSample->DEFAULT_WIDTH = 1080;
230 vEncSample->DEFAULT_HEIGHT = 1920;
231 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case05.h265";
232 vEncSample->FACTOR_ENABLE = true;
233 vEncSample->MAXBITE_ENABLE = true;
234 vEncSample->MODE_ENABLE = true;
235 vEncSample->enableParameter = true;
236 vEncSample->MAXBITE_ENABLE_RUN = true;
237 vEncSample->FACTOR_ENABLE_RUN = true;
238 vEncSample->DEFAULT_BITRATE_MODE = SQR;
239 vEncSample->DEFAULT_MAX_BITRATE = 100000000;
240 vEncSample->DEFAULT_SQR_FACTOR = 51;
241 vEncSample->DEFAULT_MAX_BITRATE_RUN = 1000000;
242 vEncSample->DEFAULT_SQR_FACTOR_RUN = 1;
243 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
244 vEncSample->INP_DIR = INP_DIR_1080_30;
245 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
246 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
247 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
248 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
249 vEncSample->WaitForEOS();
250 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
251 }
252
253 /**
254 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_006
255 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_006
256 * @tc.desc : function test
257 */
258 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_006, TestSize.Level2)
259 {
260 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
261 if (!isSupported) {
262 return;
263 }
264 auto vEncSample = make_unique<VEncAPI11Sample>();
265 vEncSample->DEFAULT_WIDTH = 1080;
266 vEncSample->DEFAULT_HEIGHT = 1920;
267 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case06.h265";
268 vEncSample->MODE_ENABLE = true;
269 vEncSample->enableParameter = true;
270 vEncSample->MAXBITE_ENABLE_RUN = true;
271 vEncSample->FACTOR_ENABLE_RUN = true;
272 vEncSample->DEFAULT_BITRATE_MODE = SQR;
273 vEncSample->DEFAULT_MAX_BITRATE_RUN = 4000000;vEncSample->DEFAULT_SQR_FACTOR_RUN = 28;
274 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
275 vEncSample->INP_DIR = INP_DIR_1080_30;
276 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
277 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
278 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
279 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
280 vEncSample->WaitForEOS();
281 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
282 }
283
284 /**
285 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_007
286 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_007
287 * @tc.desc : function test
288 */
289 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_007, TestSize.Level2)
290 {
291 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
292 if (!isSupported) {
293 return;
294 }
295 auto vEncSample = make_unique<VEncAPI11Sample>();
296 vEncSample->DEFAULT_WIDTH = 1080;
297 vEncSample->DEFAULT_HEIGHT = 1920;
298 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case07.h265";
299 vEncSample->MODE_ENABLE = true;
300 vEncSample->enableParameter = true;
301 vEncSample->FACTOR_ENABLE_RUN = true;
302 vEncSample->DEFAULT_BITRATE_MODE = SQR;
303 vEncSample->DEFAULT_SQR_FACTOR_RUN = -1;
304 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
305 vEncSample->INP_DIR = INP_DIR_1080_30;
306 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
307 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
308 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
309 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
310 vEncSample->WaitForEOS();
311 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
312 }
313
314 /**
315 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_008
316 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_008
317 * @tc.desc : function test
318 */
319 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_008, TestSize.Level2)
320 {
321 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
322 if (!isSupported) {
323 return;
324 }
325 auto vEncSample = make_unique<VEncAPI11Sample>();
326 vEncSample->DEFAULT_WIDTH = 1080;
327 vEncSample->DEFAULT_HEIGHT = 1920;
328 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case08.h265";
329 vEncSample->MODE_ENABLE = true;
330 vEncSample->enableParameter = true;
331 vEncSample->MAXBITE_ENABLE_RUN = true;
332 vEncSample->DEFAULT_BITRATE_MODE = SQR;
333 vEncSample->DEFAULT_MAX_BITRATE_RUN = 200000000;
334 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
335 vEncSample->INP_DIR = INP_DIR_1080_30;
336 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
337 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
338 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
339 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
340 vEncSample->WaitForEOS();
341 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
342 }
343
344 /**
345 * @tc.number : VIDEO_HW_ENCODE_FUNC_SQR_009
346 * @tc.name : VIDEO_HW_ENCODE_FUNC_SQR_009
347 * @tc.desc : function test
348 */
349 HWTEST_F(HwEncSqrFuncTest, VIDEO_HW_ENCODE_FUNC_SQR_009, TestSize.Level2)
350 {
351 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
352 if (!isSupported) {
353 return;
354 }
355 auto vEncSample = make_unique<VEncAPI11Sample>();
356 vEncSample->DEFAULT_WIDTH = 1080;
357 vEncSample->DEFAULT_HEIGHT = 1920;
358 vEncSample->OUT_DIR = "/data/test/media/1080_1920_nv12_buffer_case09.h265";
359 vEncSample->QUALITY_ENABLE_RUN = true;
360 vEncSample->FACTOR_ENABLE = true;
361 vEncSample->MAXBITE_ENABLE = true;
362 vEncSample->MODE_ENABLE = true;
363 vEncSample->enableParameter = true;
364 vEncSample->MAXBITE_ENABLE_RUN = true;
365 vEncSample->FACTOR_ENABLE_RUN = true;
366 vEncSample->SETBIRATE_RUN = true;
367 vEncSample->DEFAULT_BITRATE_MODE = SQR;
368 vEncSample->DEFAULT_MAX_BITRATE = 4000000;
369 vEncSample->DEFAULT_SQR_FACTOR = 28;
370 vEncSample->DEFAULT_MAX_BITRATE_RUN = 10000000;
371 vEncSample->DEFAULT_BITRATE_RUN = 100000000;
372 vEncSample->DEFAULT_SQR_FACTOR_RUN = 23;
373 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
374 vEncSample->INP_DIR = INP_DIR_1080_30;
375 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
376 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
377 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoderSqr());
378 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
379 vEncSample->WaitForEOS();
380 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
381 }
382 } // namespace