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 <string>
16 #include <limits>
17 #include "meta/format.h"
18 #include "gtest/gtest.h"
19 #include "native_avcodec_videoencoder.h"
20 #include "native_averrors.h"
21 #include "videoenc_api11_sample.h"
22 #include "native_avcodec_base.h"
23 #include "avcodec_codec_name.h"
24 #include "native_avcapability.h"
25 #include "avcodec_info.h"
26 #include "avcodec_list.h"
27 #include "avcodec_common.h"
28
29 using namespace std;
30 using namespace OHOS;
31 using namespace OHOS::Media;
32 using namespace testing::ext;
33 namespace {
34 OH_AVCodec *venc_ = NULL;
35 OH_AVCapability *cap = nullptr;
36 OH_AVCapability *cap_hevc = nullptr;
37 constexpr uint32_t CODEC_NAME_SIZE = 128;
38 char g_codecName[CODEC_NAME_SIZE] = {};
39 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
40
41 fileInfo file_640_480_rgba{"/data/test/media/640_480.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 640, 480 };
42 fileInfo file_1280_536_nv21{"/data/test/media/1280_536_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1280, 536 };
43 fileInfo file_1280_720_nv12{"/data/test/media/1280_720_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 720 };
44 fileInfo file_1920_816_rgba{"/data/test/media/1920_816.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 1920, 816 };
45 fileInfo file_1920_1080_nv21{"/data/test/media/1920_1080_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1920, 1080 };
46 fileInfo file_3840_2160_nv12{"/data/test/media/3840_2160_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 3840, 2160 };
47 } // namespace
48 namespace OHOS {
49 namespace Media {
50 class HwEncFunc3NdkTest : public testing::Test {
51 public:
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp() override;
55 void TearDown() override;
56 void InputFunc();
57 void OutputFunc();
58 void Release();
59 int32_t Stop();
60 };
61 } // namespace Media
62 } // namespace OHOS
63
SetUpTestCase()64 void HwEncFunc3NdkTest::SetUpTestCase()
65 {
66 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
67 const char *tmpCodecName = OH_AVCapability_GetName(cap);
68 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
69 cout << "memcpy failed" << endl;
70 cout << "codecname: " << g_codecName << endl;
71 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
72 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
73 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
74 cout << "memcpy failed" << endl;
75 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
76 }
TearDownTestCase()77 void HwEncFunc3NdkTest::TearDownTestCase() {}
SetUp()78 void HwEncFunc3NdkTest::SetUp() {}
TearDown()79 void HwEncFunc3NdkTest::TearDown()
80 {
81 if (venc_ != NULL) {
82 OH_VideoEncoder_Destroy(venc_);
83 venc_ = nullptr;
84 }
85 }
86 namespace {
87
88 /**
89 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0010
90 * @tc.name : 264 video cbr sync encode
91 * @tc.desc : function test
92 */
93 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0010, TestSize.Level2)
94 {
95 if (cap != nullptr) {
96 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
97 if (format != nullptr) {
98 OH_AVFormat_Destroy(format);
99 format = nullptr;
100 auto vEncSample = make_unique<VEncAPI11Sample>();
101 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
102 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0010.h264";
103 vEncSample->enbleSyncMode = 1;
104 vEncSample->enbleBFrameMode = 1;
105 vEncSample->DEFAULT_BITRATE_MODE = CBR;
106 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
107 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
108 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
109 vEncSample->WaitForEOS();
110 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
111 }
112 }
113 }
114
115 /**
116 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0020
117 * @tc.name : 264 video cq sync encode
118 * @tc.desc : function test
119 */
120 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0020, TestSize.Level2)
121 {
122 if (cap != nullptr) {
123 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
124 if (format != nullptr) {
125 OH_AVFormat_Destroy(format);
126 format = nullptr;
127 auto vEncSample = make_unique<VEncAPI11Sample>();
128 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
129 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0020.h264";
130 vEncSample->enbleSyncMode = 1;
131 vEncSample->enbleBFrameMode = 1;
132 vEncSample->DEFAULT_BITRATE_MODE = CQ;
133 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
134 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
135 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
136 vEncSample->WaitForEOS();
137 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
138 }
139 }
140 }
141
142 /**
143 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0030
144 * @tc.name : 264 video sqr sync encode
145 * @tc.desc : function test
146 */
147 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0030, TestSize.Level2)
148 {
149 if (cap != nullptr) {
150 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
151 if (format != nullptr) {
152 OH_AVFormat_Destroy(format);
153 format = nullptr;
154 auto vEncSample = make_unique<VEncAPI11Sample>();
155 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
156 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0030.h264";
157 vEncSample->enbleSyncMode = 1;
158 vEncSample->enbleBFrameMode = 1;
159 vEncSample->DEFAULT_BITRATE_MODE = SQR;
160 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
161 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
162 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
163 vEncSample->WaitForEOS();
164 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
165 }
166 }
167 }
168
169 /**
170 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0040
171 * @tc.name : 264 video vbr sync encode
172 * @tc.desc : function test
173 */
174 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0040, TestSize.Level0)
175 {
176 if (cap != nullptr) {
177 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
178 if (format != nullptr) {
179 OH_AVFormat_Destroy(format);
180 format = nullptr;
181 auto vEncSample = make_unique<VEncAPI11Sample>();
182 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
183 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0040.h264";
184 vEncSample->enbleSyncMode = 1;
185 vEncSample->enbleBFrameMode = 1;
186 vEncSample->DEFAULT_BITRATE_MODE = VBR;
187 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
188 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
189 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
190 vEncSample->WaitForEOS();
191 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
192 }
193 }
194 }
195
196 /**
197 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0050
198 * @tc.name : 264 video surface sync encode
199 * @tc.desc : function test
200 */
201 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0050, TestSize.Level0)
202 {
203 if (cap != nullptr) {
204 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
205 if (format != nullptr) {
206 OH_AVFormat_Destroy(format);
207 format = nullptr;
208 auto vEncSample = make_unique<VEncAPI11Sample>();
209 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
210 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0050.h264";
211 vEncSample->enbleSyncMode = 1;
212 vEncSample->enbleBFrameMode = 1;
213 vEncSample->SURF_INPUT = true;
214 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
215 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
216 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
217 vEncSample->WaitForEOS();
218 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
219 }
220 }
221 }
222
223 /**
224 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0060
225 * @tc.name : 264 video resolution change sync encode
226 * @tc.desc : function test
227 */
228 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0060, TestSize.Level2)
229 {
230 if (cap != nullptr) {
231 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap, VIDEO_ENCODER_B_FRAME);
232 if (format != nullptr) {
233 OH_AVFormat_Destroy(format);
234 format = nullptr;
235 auto vEncSample = make_unique<VEncAPI11Sample>();
236 vEncSample->DEFAULT_WIDTH = 3840;
237 vEncSample->DEFAULT_HEIGHT = 2160;
238 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0070.h264";
239 vEncSample->SURF_INPUT = true;
240 vEncSample->readMultiFiles = true;
241 vEncSample->enbleSyncMode = 1;
242 vEncSample->enbleBFrameMode = 1;
243 vEncSample->fileInfos.push_back(file_640_480_rgba);
244 vEncSample->fileInfos.push_back(file_1280_536_nv21);
245 vEncSample->fileInfos.push_back(file_1280_720_nv12);
246 vEncSample->fileInfos.push_back(file_1920_816_rgba);
247 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
248 vEncSample->fileInfos.push_back(file_3840_2160_nv12);
249 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
250 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
251 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
252 vEncSample->WaitForEOS();
253 }
254 }
255 }
256
257 /**
258 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0070
259 * @tc.name : 265 video CBR sync encode
260 * @tc.desc : function test
261 */
262 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0070, TestSize.Level2)
263 {
264 if (cap_hevc != nullptr) {
265 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap_hevc, VIDEO_ENCODER_B_FRAME);
266 if (format != nullptr) {
267 OH_AVFormat_Destroy(format);
268 format = nullptr;
269 auto vEncSample = make_unique<VEncAPI11Sample>();
270 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
271 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0070.h265";
272 vEncSample->enbleSyncMode = 1;
273 vEncSample->enbleBFrameMode = 1;
274 vEncSample->DEFAULT_BITRATE_MODE = CBR;
275 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
276 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
277 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
278 vEncSample->WaitForEOS();
279 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
280 }
281 }
282 }
283
284 /**
285 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0080
286 * @tc.name : 265 video CQ sync encode
287 * @tc.desc : function test
288 */
289 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0080, TestSize.Level2)
290 {
291 if (cap_hevc != nullptr) {
292 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap_hevc, VIDEO_ENCODER_B_FRAME);
293 if (format != nullptr) {
294 OH_AVFormat_Destroy(format);
295 format = nullptr;
296 auto vEncSample = make_unique<VEncAPI11Sample>();
297 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
298 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0080.h265";
299 vEncSample->enbleSyncMode = 1;
300 vEncSample->enbleBFrameMode = 1;
301 vEncSample->DEFAULT_BITRATE_MODE = CQ;
302 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
303 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
304 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
305 vEncSample->WaitForEOS();
306 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
307 }
308 }
309 }
310
311 /**
312 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0090
313 * @tc.name : 265 video sqr sync encode
314 * @tc.desc : function test
315 */
316 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0090, TestSize.Level2)
317 {
318 if (cap_hevc != nullptr) {
319 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap_hevc, VIDEO_ENCODER_B_FRAME);
320 if (format != nullptr) {
321 OH_AVFormat_Destroy(format);
322 format = nullptr;
323 auto vEncSample = make_unique<VEncAPI11Sample>();
324 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
325 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0090.h265";
326 vEncSample->enbleSyncMode = 1;
327 vEncSample->enbleBFrameMode = 1;
328 vEncSample->DEFAULT_BITRATE_MODE = SQR;
329 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
330 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
331 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
332 vEncSample->WaitForEOS();
333 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
334 }
335 }
336 }
337
338 /**
339 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0100
340 * @tc.name : 265 video vbr sync encode
341 * @tc.desc : function test
342 */
343 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0100, TestSize.Level0)
344 {
345 if (cap_hevc != nullptr) {
346 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap_hevc, VIDEO_ENCODER_B_FRAME);
347 if (format != nullptr) {
348 OH_AVFormat_Destroy(format);
349 format = nullptr;
350 auto vEncSample = make_unique<VEncAPI11Sample>();
351 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
352 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0100.h265";
353 vEncSample->enbleSyncMode = 1;
354 vEncSample->enbleBFrameMode = 1;
355 vEncSample->DEFAULT_BITRATE_MODE = VBR;
356 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
357 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
358 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
359 vEncSample->WaitForEOS();
360 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
361 }
362 }
363 }
364
365 /**
366 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0110
367 * @tc.name : 265 video surface sync encode
368 * @tc.desc : function test
369 */
370 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0110, TestSize.Level0)
371 {
372 if (cap_hevc != nullptr) {
373 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap_hevc, VIDEO_ENCODER_B_FRAME);
374 if (format != nullptr) {
375 OH_AVFormat_Destroy(format);
376 format = nullptr;
377 auto vEncSample = make_unique<VEncAPI11Sample>();
378 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
379 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0110.h265";
380 vEncSample->enbleSyncMode = 1;
381 vEncSample->enbleBFrameMode = 1;
382 vEncSample->SURF_INPUT = true;
383 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
384 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
385 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
386 vEncSample->WaitForEOS();
387 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
388 }
389 }
390 }
391
392 /**
393 * @tc.number : VIDEO_ENCODE_BFRAME_SYNC_0120
394 * @tc.name : 265 video resolution change sync encode
395 * @tc.desc : function test
396 */
397 HWTEST_F(HwEncFunc3NdkTest, VIDEO_ENCODE_BFRAME_SYNC_0120, TestSize.Level2)
398 {
399 if (cap_hevc != nullptr) {
400 OH_AVFormat *format = OH_AVCapability_GetFeatureProperties(cap_hevc, VIDEO_ENCODER_B_FRAME);
401 if (format != nullptr) {
402 OH_AVFormat_Destroy(format);
403 format = nullptr;
404 auto vEncSample = make_unique<VEncAPI11Sample>();
405 vEncSample->DEFAULT_WIDTH = 3840;
406 vEncSample->DEFAULT_HEIGHT = 2160;
407 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_BFRAME_SYNC_0120.h265";
408 vEncSample->SURF_INPUT = true;
409 vEncSample->readMultiFiles = true;
410 vEncSample->enbleSyncMode = 1;
411 vEncSample->enbleBFrameMode = 1;
412 vEncSample->fileInfos.push_back(file_640_480_rgba);
413 vEncSample->fileInfos.push_back(file_1280_536_nv21);
414 vEncSample->fileInfos.push_back(file_1280_720_nv12);
415 vEncSample->fileInfos.push_back(file_1920_816_rgba);
416 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
417 vEncSample->fileInfos.push_back(file_3840_2160_nv12);
418 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
419 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
420 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
421 vEncSample->WaitForEOS();
422 }
423 }
424 }
425 } // namespace