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 "VideoencApi11Sample.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 namespace {
30 OH_AVCodec *gVenc = nullptr;
31 OH_AVCapability *g_capHevc = nullptr;
32 OH_AVCapability *gCap = nullptr;
33 const char *OUT_DIR = "/data/test/media/VIDEO_ENCODE_FILE_ROI.h265";
34 const char *CODEC_NAME = "";
35 const char *CODEC_HEVC = "";
36 } // namespace
37 namespace OHOS {
38 namespace Media {
39 class HwEncFuncRoiTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp() override;
44 void TearDown() override;
45 void InputFunc();
46 void OutputFunc();
47 void Release();
48 int32_t Stop();
49
50 protected:
51 const char *INP_DIR_1920_30 = "/data/test/media/1920_1080_nv21.yuv";
52 const char *INP_DIR_1080_30 = "/data/test/media/1080_1920_nv12.yuv";
53 };
54 } // namespace Media
55 } // namespace OHOS
56
57 using namespace std;
58 using namespace OHOS;
59 using namespace OHOS::Media;
60 using namespace testing::ext;
61
SetUpTestCase()62 void HwEncFuncRoiTest::SetUpTestCase()
63 {
64 gCap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
65 CODEC_NAME = OH_AVCapability_GetName(gCap);
66 cout << "codecname: " << CODEC_NAME << endl;
67 g_capHevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
68 CODEC_HEVC = OH_AVCapability_GetName(g_capHevc);
69 cout << "codecname_hevc: " << CODEC_HEVC << endl;
70 }
TearDownTestCase()71 void HwEncFuncRoiTest::TearDownTestCase() {}
SetUp()72 void HwEncFuncRoiTest::SetUp() {}
TearDown()73 void HwEncFuncRoiTest::TearDown()
74 {
75 if (gVenc != NULL) {
76 OH_VideoEncoder_Destroy(gVenc);
77 gVenc = nullptr;
78 }
79 }
80 namespace {
81 /**
82 * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_001
83 * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_001
84 * @tc.desc : function test
85 */
86 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_001, TestSize.Level1)
87 {
88 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_CBR);
89 if (!isSupported) {
90 return;
91 }
92 auto vEncSample = make_unique<VEncAPI11Sample>();
93 vEncSample->DEFAULT_WIDTH = 1920;
94 vEncSample->DEFAULT_HEIGHT = 1080;
95 vEncSample->roiInfo = "10,10-100,100=-8;100,1-200,200=-4;"
96 "300,350-430,440=-4;510,54050,690=-4;"
97 "700,710-820,1000=-4";
98 vEncSample->OUT_DIR = OUT_DIR;
99 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
100 vEncSample->DEFAULT_BITRATE_MODE = CBR;
101 vEncSample->INP_DIR = INP_DIR_1920_30;
102 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
103 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
104 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
105 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
106 vEncSample->WaitForEOS();
107 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
108 }
109
110 /**
111 * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_002
112 * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_002
113 * _002
114 * @tc.desc : function test
115 */
116 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_002, TestSize.Level1)
117 {
118 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_VBR);
119 if (!isSupported) {
120 return;
121 }
122 auto vEncSample = make_unique<VEncAPI11Sample>();
123 vEncSample->DEFAULT_WIDTH = 1920;
124 vEncSample->DEFAULT_HEIGHT = 1080;
125 vEncSample->roiInfo = "440,1272-1080,1920=-51";
126 vEncSample->OUT_DIR = OUT_DIR;
127 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
128 vEncSample->DEFAULT_BITRATE_MODE = VBR;
129 vEncSample->INP_DIR = INP_DIR_1920_30;
130 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
131 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
132 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
133 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
134 vEncSample->WaitForEOS();
135 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
136 }
137
138 /**
139 * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_003
140 * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_003
141 * @tc.desc : function test
142 */
143 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_003, TestSize.Level1)
144 {
145 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_CBR);
146 if (!isSupported) {
147 return;
148 }
149 auto vEncSample = make_unique<VEncAPI11Sample>();
150 vEncSample->DEFAULT_WIDTH = 1080;
151 vEncSample->DEFAULT_HEIGHT = 1920;
152 vEncSample->roiInfo = "10,10-100,100=-4;100,100-200,200=-4;350,300-400,430=-4;540,510-690,650=51";
153 vEncSample->OUT_DIR = OUT_DIR;
154 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
155 vEncSample->INP_DIR = INP_DIR_1080_30;
156 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
157 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
158 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
159 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
160 vEncSample->WaitForEOS();
161 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
162 }
163
164 // /**
165 // * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_004
166 // * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_004
167 // * @tc.desc : function test
168 // */
169 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_004, TestSize.Level1)
170 {
171 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_SQR);
172 if (!isSupported) {
173 return;
174 }
175 auto vEncSample = make_unique<VEncAPI11Sample>();
176 vEncSample->DEFAULT_WIDTH = 1080;
177 vEncSample->DEFAULT_HEIGHT = 1920;
178 vEncSample->roiInfo = "0,0-500,500;500,500-600,600;600,500-700,600";
179 vEncSample->OUT_DIR = OUT_DIR;
180 vEncSample->DEFAULT_BITRATE_MODE = SQR;
181 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
182 vEncSample->INP_DIR = INP_DIR_1080_30;
183 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
184 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
185 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
186 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
187 vEncSample->WaitForEOS();
188 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
189 }
190
191 // /**
192 // * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_005
193 // * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_005
194 // * @tc.desc : function test
195 // */
196 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_005, TestSize.Level1)
197 {
198 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_SQR);
199 if (!isSupported) {
200 return;
201 }
202 auto vEncSample = make_unique<VEncAPI11Sample>();
203 vEncSample->DEFAULT_WIDTH = 1920;
204 vEncSample->DEFAULT_HEIGHT = 1080;
205 vEncSample->roiInfo = "123456789123,123456789123-123456789-12345678912=-8";
206 vEncSample->OUT_DIR = OUT_DIR;
207 vEncSample->DEFAULT_BITRATE_MODE = SQR;
208 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
209 vEncSample->INP_DIR = INP_DIR_1920_30;
210 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
211 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
212 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
213 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
214 vEncSample->WaitForEOS();
215 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
216 }
217
218 /**
219 * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_006
220 * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_006
221 * @tc.desc : function test
222 */
223 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_006, TestSize.Level1)
224 {
225 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_CBR);
226 if (!isSupported) {
227 return;
228 }
229 auto vEncSample = make_unique<VEncAPI11Sample>();
230 vEncSample->DEFAULT_WIDTH = 1080;
231 vEncSample->DEFAULT_HEIGHT = 1920;
232 vEncSample->roiInfo = "10,10-100,100=-8;100,10-200,200=-4;"
233 "300,350-430,440=-4;510,540650,690=-4;"
234 "700,710-80,1000=-4";
235 vEncSample->OUT_DIR = OUT_DIR;
236 vEncSample->SURF_INPUT = true;
237 vEncSample->DEFAULT_BITRATE_MODE = CBR;
238 vEncSample->INP_DIR = INP_DIR_1080_30;
239 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
240 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
241 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
242 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
243 vEncSample->WaitForEOS();
244 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
245 }
246
247 /**
248 * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_007
249 * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_007
250 * @tc.desc : function test
251 */
252 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_007, TestSize.Level1)
253 {
254 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_VBR);
255 if (!isSupported) {
256 return;
257 }
258 auto vEncSample = make_unique<VEncAPI11Sample>();
259 vEncSample->DEFAULT_WIDTH = 1080;
260 vEncSample->DEFAULT_HEIGHT = 1920;
261 vEncSample->roiInfo = "400,1272-1080,1920=-51";
262 vEncSample->OUT_DIR = OUT_DIR;
263 vEncSample->SURF_INPUT = true;
264 vEncSample->DEFAULT_BITRATE_MODE = VBR;
265 vEncSample->INP_DIR = INP_DIR_1080_30;
266 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
267 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
268 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
269 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
270 vEncSample->WaitForEOS();
271 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
272 }
273
274 /**
275 * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_008
276 * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_008
277 * @tc.desc : function test
278 */
279 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_008, TestSize.Level1)
280 {
281 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_CBR);
282 if (!isSupported) {
283 return;
284 }
285 auto vEncSample = make_unique<VEncAPI11Sample>();
286 vEncSample->DEFAULT_WIDTH = 1080;
287 vEncSample->DEFAULT_HEIGHT = 1920;
288 vEncSample->roiInfo = "10,10-100,100=-4;100,100-200,200=-4;350,300-400,430=-4;540,510-690,650=51";
289 vEncSample->OUT_DIR = OUT_DIR;
290 vEncSample->SURF_INPUT = true;
291 vEncSample->DEFAULT_BITRATE_MODE = CBR;
292 vEncSample->INP_DIR = INP_DIR_1080_30;
293 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
294 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
295 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
296 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
297 vEncSample->WaitForEOS();
298 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
299 }
300
301 // /**
302 // * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_009
303 // * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_009
304 // * @tc.desc : function test
305 // */
306 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_009, TestSize.Level1)
307 {
308 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_SQR);
309 if (!isSupported) {
310 return;
311 }
312 auto vEncSample = make_unique<VEncAPI11Sample>();
313 vEncSample->DEFAULT_WIDTH = 1080;
314 vEncSample->DEFAULT_HEIGHT = 1920;
315 vEncSample->roiInfo = "0,0-500,500;500,500-600,600;600,500-700,600";
316 vEncSample->OUT_DIR = OUT_DIR;
317 vEncSample->SURF_INPUT = true;
318 vEncSample->DEFAULT_BITRATE_MODE = SQR;
319 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
320 vEncSample->INP_DIR = INP_DIR_1080_30;
321 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
322 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
323 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
324 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
325 vEncSample->WaitForEOS();
326 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
327 }
328
329 // /**
330 // * @tc.number : VIDEO_HW_ENCODE_ROI_FUNC_010
331 // * @tc.name : VIDEO_HW_ENCODE_ROI_FUNC_010
332 // * @tc.desc : function test
333 // */
334 HWTEST_F(HwEncFuncRoiTest, VIDEO_HW_ENCODE_ROI_FUNC_010, TestSize.Level1)
335 {
336 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capHevc, BITRATE_MODE_SQR);
337 if (!isSupported) {
338 return;
339 }
340 auto vEncSample = make_unique<VEncAPI11Sample>();
341 vEncSample->DEFAULT_WIDTH = 1080;
342 vEncSample->DEFAULT_HEIGHT = 1920;
343 vEncSample->roiInfo = "123456789123,123456789123-123456789-12345678912=-8";
344 vEncSample->OUT_DIR = OUT_DIR;
345 vEncSample->SURF_INPUT = true;
346 vEncSample->DEFAULT_BITRATE_MODE = SQR;
347 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
348 vEncSample->INP_DIR = INP_DIR_1080_30;
349 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_HEVC));
350 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
351 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
352 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
353 vEncSample->WaitForEOS();
354 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
355 }
356 } // namespace