1 /*
2 * Copyright (C) 2023 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
17 #include "gtest/gtest.h"
18 #include "native_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videoenc_ndk_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24
25 namespace {
26 OH_AVCodec *venc_ = NULL;
27 OH_AVCapability *cap = nullptr;
28 OH_AVCapability *cap_hevc = nullptr;
29 const char *CODEC_MIME = "video/avc";
30 const char *CODEC_MIME_HEVC = "video/hevc";
31 constexpr uint32_t CODEC_NAME_SIZE = 128;
32 char g_codecName[CODEC_NAME_SIZE] = {};
33 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
34
35 const char *INP_DIR_720 = "/data/test/media/1280_720_nv.yuv";
36 constexpr uint32_t SECOND = 1000;
37 constexpr uint32_t DEFAULT_WIDTH = 1280;
38 constexpr uint32_t DEFAULT_HEIGHT = 720;
39 } // namespace
40 namespace OHOS {
41 namespace Media {
42 class HwEncFuncNdkTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp() override;
47 void TearDown() override;
48 void InputFunc();
49 void OutputFunc();
50 void Release();
51 int32_t Stop();
52 };
53 } // namespace Media
54 } // namespace OHOS
55
56 using namespace std;
57 using namespace OHOS;
58 using namespace OHOS::Media;
59 using namespace testing::ext;
60
SetUpTestCase()61 void HwEncFuncNdkTest::SetUpTestCase()
62 {
63 cap = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME, true, HARDWARE);
64 const char *tmpCodecName = OH_AVCapability_GetName(cap);
65 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
66 cout << "memcpy failed" << endl;
67 cout << "codecname: " << g_codecName << endl;
68 cap_hevc = OH_AVCodec_GetCapabilityByCategory(CODEC_MIME_HEVC, true, HARDWARE);
69 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
70 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
71 cout << "memcpy failed" << endl;
72 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
73 }
TearDownTestCase()74 void HwEncFuncNdkTest::TearDownTestCase() {}
SetUp()75 void HwEncFuncNdkTest::SetUp() {}
TearDown()76 void HwEncFuncNdkTest::TearDown()
77 {
78 if (venc_ != NULL) {
79 OH_VideoEncoder_Destroy(venc_);
80 venc_ = nullptr;
81 }
82 }
83 namespace {
84 /**
85 * @tc.number : VIDEO_ENCODE_FUNCTION_0100
86 * @tc.name : create by mime
87 * @tc.desc : function test
88 */
89 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0100, TestSize.Level1)
90 {
91 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
92 ASSERT_NE(nullptr, venc_);
93 }
94
95 /**
96 * @tc.number : VIDEO_ENCODE_FUNCTION_0200
97 * @tc.name : create by name
98 * @tc.desc : function test
99 */
100 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0200, TestSize.Level1)
101 {
102 venc_ = OH_VideoEncoder_CreateByName(g_codecName);
103 ASSERT_NE(nullptr, venc_);
104 }
105
106 /**
107 * @tc.number : VIDEO_ENCODE_FUNCTION_0300
108 * @tc.name : create no exist encoder
109 * @tc.desc : function test
110 */
111 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0300, TestSize.Level1)
112 {
113 venc_ = OH_VideoEncoder_CreateByName("aabbccdd");
114 ASSERT_EQ(nullptr, venc_);
115 }
116
117 /**
118 * @tc.number : VIDEO_ENCODE_FUNCTION_0400
119 * @tc.name : test encode buffer
120 * @tc.desc : function test
121 */
122 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0400, TestSize.Level1)
123 {
124 auto vEncSample = make_unique<VEncNdkSample>();
125 vEncSample->INP_DIR = INP_DIR_720;
126 vEncSample->DEFAULT_WIDTH = 1280;
127 vEncSample->DEFAULT_HEIGHT = 720;
128 vEncSample->DEFAULT_FRAME_RATE = 30;
129 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
130 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
131 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
132 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
133 vEncSample->WaitForEOS();
134 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
135 }
136
137 /**
138 * @tc.number : VIDEO_ENCODE_FUNCTION_0500
139 * @tc.name : test encode surface
140 * @tc.desc : function test
141 */
142 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0500, TestSize.Level1)
143 {
144 auto vEncSample = make_unique<VEncNdkSample>();
145 vEncSample->INP_DIR = INP_DIR_720;
146 vEncSample->DEFAULT_WIDTH = 1280;
147 vEncSample->DEFAULT_HEIGHT = 720;
148 vEncSample->DEFAULT_FRAME_RATE = 30;
149 vEncSample->SURFACE_INPUT = true;
150 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
151 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
152 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
153 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
154 vEncSample->WaitForEOS();
155 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
156 }
157
158 /**
159 * @tc.number : VIDEO_ENCODE_FUNCTION_0600
160 * @tc.name : set force IDR when encoding
161 * @tc.desc : function test
162 */
163 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0600, TestSize.Level1)
164 {
165 auto vEncSample = make_unique<VEncNdkSample>();
166 vEncSample->INP_DIR = INP_DIR_720;
167 vEncSample->DEFAULT_WIDTH = 1280;
168 vEncSample->DEFAULT_HEIGHT = 720;
169 vEncSample->DEFAULT_FRAME_RATE = 30;
170 vEncSample->enableForceIDR = true;
171 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
172 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
173 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
174 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
175 vEncSample->WaitForEOS();
176 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
177 }
178
179 /**
180 * @tc.number : VIDEO_ENCODE_FUNCTION_0700
181 * @tc.name : set color format
182 * @tc.desc : function test
183 */
184 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0700, TestSize.Level1)
185 {
186 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
187 ASSERT_NE(nullptr, venc_);
188 OH_AVFormat *format = OH_AVFormat_Create();
189 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_RANGE_FLAG, 1));
190 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_COLOR_PRIMARIES, OH_ColorPrimary::COLOR_PRIMARY_BT709));
191 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_TRANSFER_CHARACTERISTICS,
192 OH_TransferCharacteristic::TRANSFER_CHARACTERISTIC_LINEAR));
193 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_MATRIX_COEFFICIENTS,
194 OH_MatrixCoefficient::MATRIX_COEFFICIENT_YCGCO));
195 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
196 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
197 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
198 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
199 OH_AVFormat_Destroy(format);
200 }
201
202 /**
203 * @tc.number : VIDEO_ENCODE_FUNCTION_0800
204 * @tc.name : set key frame interval
205 * @tc.desc : function test
206 */
207 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0800, TestSize.Level1)
208 {
209 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
210 ASSERT_NE(nullptr, venc_);
211 OH_AVFormat *format = OH_AVFormat_Create();
212
213 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_I_FRAME_INTERVAL, SECOND));
214 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
215 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
216 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
217 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
218 OH_AVFormat_Destroy(format);
219 }
220
221 /**
222 * @tc.number : VIDEO_ENCODE_FUNCTION_0900
223 * @tc.name : set profile level
224 * @tc.desc : function test
225 */
226 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_0900, TestSize.Level1)
227 {
228 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
229 ASSERT_NE(nullptr, venc_);
230 OH_AVFormat *format = OH_AVFormat_Create();
231
232 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_PROFILE, AVC_PROFILE_BASELINE));
233 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
234 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
235 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
236 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
237 OH_AVFormat_Destroy(format);
238 }
239
240 /**
241 * @tc.number : VIDEO_ENCODE_FUNCTION_1000
242 * @tc.name : set bitrate mode
243 * @tc.desc : function test
244 */
245 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1000, TestSize.Level1)
246 {
247 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
248 ASSERT_NE(nullptr, venc_);
249 OH_AVFormat *format = OH_AVFormat_Create();
250
251 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR));
252 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
253 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
254 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
255 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
256 OH_AVFormat_Destroy(format);
257 }
258
259 /**
260 * @tc.number : VIDEO_ENCODE_FUNCTION_1100
261 * @tc.name : set bitrate value
262 * @tc.desc : function test
263 */
264 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1100, TestSize.Level1)
265 {
266 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
267 ASSERT_NE(nullptr, venc_);
268 OH_AVFormat *format = OH_AVFormat_Create();
269 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CBR));
270 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITRATE, 1000));
271 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
272 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
273 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
274 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
275 OH_AVFormat_Destroy(format);
276 }
277
278 /**
279 * @tc.number : VIDEO_ENCODE_FUNCTION_1400
280 * @tc.name : set framerate
281 * @tc.desc : function test
282 */
283 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1400, TestSize.Level1)
284 {
285 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
286 ASSERT_NE(nullptr, venc_);
287 OH_AVFormat *format = OH_AVFormat_Create();
288
289 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 60));
290 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
291 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
292 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
293 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
294 OH_AVFormat_Destroy(format);
295 }
296
297 /**
298 * @tc.number : VIDEO_ENCODE_FUNCTION_1600
299 * @tc.name : set quality
300 * @tc.desc : function test
301 */
302 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1600, TestSize.Level1)
303 {
304 venc_ = OH_VideoEncoder_CreateByMime(CODEC_MIME);
305 ASSERT_NE(nullptr, venc_);
306 OH_AVFormat *format = OH_AVFormat_Create();
307 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_ENCODE_BITRATE_MODE, CQ));
308 ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_QUALITY, 60));
309 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
310 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
311 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
312 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(venc_, format));
313 OH_AVFormat_Destroy(format);
314 }
315
316 /**
317 * @tc.number : VIDEO_ENCODE_FUNCTION_1700
318 * @tc.name : input frame after EOS
319 * @tc.desc : function test
320 */
321 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1700, TestSize.Level1)
322 {
323 auto vEncSample = make_unique<VEncNdkSample>();
324 vEncSample->INP_DIR = INP_DIR_720;
325 vEncSample->DEFAULT_WIDTH = 1280;
326 vEncSample->DEFAULT_HEIGHT = 720;
327 vEncSample->DEFAULT_FRAME_RATE = 30;
328 vEncSample->enable_random_eos = true;
329 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
330 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
331 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
332 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
333
334 vEncSample->WaitForEOS();
335
336 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
337 }
338
339 /**
340 * @tc.number : VIDEO_ENCODE_FUNCTION_1800
341 * @tc.name : encode h265 buffer
342 * @tc.desc : function test
343 */
344 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1800, TestSize.Level1)
345 {
346 auto vEncSample = make_unique<VEncNdkSample>();
347 vEncSample->INP_DIR = INP_DIR_720;
348 vEncSample->DEFAULT_WIDTH = 1280;
349 vEncSample->DEFAULT_HEIGHT = 720;
350 vEncSample->DEFAULT_FRAME_RATE = 30;
351 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
352 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
353 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
354 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
355
356 vEncSample->WaitForEOS();
357
358 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
359 }
360
361 /**
362 * @tc.number : VIDEO_ENCODE_FUNCTION_1900
363 * @tc.name : encode h265 surface
364 * @tc.desc : function test
365 */
366 HWTEST_F(HwEncFuncNdkTest, VIDEO_ENCODE_FUNCTION_1900, TestSize.Level1)
367 {
368 auto vEncSample = make_unique<VEncNdkSample>();
369 vEncSample->INP_DIR = INP_DIR_720;
370 vEncSample->DEFAULT_WIDTH = 1280;
371 vEncSample->DEFAULT_HEIGHT = 720;
372 vEncSample->DEFAULT_FRAME_RATE = 30;
373 vEncSample->SURFACE_INPUT = true;
374 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
375 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
376 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
377 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
378 vEncSample->WaitForEOS();
379 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
380 }
381 } // namespace