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* g_capEnc = nullptr;
32 const char* CODEC_NAME = "";
33 } // namespace
34
35 namespace OHOS {
36 namespace Media {
37 class HwEncApiNdkTest : public testing::Test {
38 public:
39 // SetUpTestCase: Called before all test cases
40 static void SetUpTestCase(void);
41 // TearDownTestCase: Called after all test case
42 static void TearDownTestCase(void);
43 // SetUp: Called before each test cases
44 void SetUp(void);
45 // TearDown: Called after each test cases
46 void TearDown(void);
47 };
48
SetUpTestCase()49 void HwEncApiNdkTest::SetUpTestCase()
50 {
51 g_capEnc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
52 CODEC_NAME = OH_AVCapability_GetName(g_capEnc);
53 cout << "CODEC_NAME: " << CODEC_NAME << endl;
54 }
TearDownTestCase()55 void HwEncApiNdkTest::TearDownTestCase() {}
SetUp()56 void HwEncApiNdkTest::SetUp() {}
TearDown()57 void HwEncApiNdkTest::TearDown()
58 {
59 if (gVenc != NULL) {
60 OH_VideoEncoder_Destroy(gVenc);
61 gVenc = nullptr;
62 }
63 }
64 } // namespace Media
65 } // namespace OHOS
66
67 namespace {
68 /**
69 * @tc.number : VIDEO_HW_ENCODE_PTS_FUNC_001
70 * @tc.name : VIDEO_HW_ENCODE_PTS_FUNC_001
71 * @tc.desc : function test
72 */
73 HWTEST_F(HwEncApiNdkTest, VIDEO_HW_ENCODE_PTS_FUNC_001, TestSize.Level1)
74 {
75 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
76 if (!isSupported) {
77 return;
78 }
79 auto vEncSample = make_unique<VEncAPI11Sample>();
80 string timeStampFilePath = "/data/test/media/xtscase_01_sqr_buffer.txt";
81 string inputDir = "";
82 string outputDir = "";
83 uint32_t width = 0;
84 uint32_t height = 0;
85 uint32_t bitrateMode = 0;
86 uint32_t bitRate = 0;
87 bool surfaceMode = false;
88 vEncSample->LoadTimeStampData(timeStampFilePath, inputDir, outputDir, width, height,
89 bitrateMode, bitRate, surfaceMode);
90 char *input = new char[1024];
91 char *output = new char[1024];
92 snprintf(input, 1024, "%s", inputDir.c_str());
93 snprintf(output, 1024, "%s", outputDir.c_str());
94 vEncSample->MAXBITE_ENABLE = true;
95 vEncSample->INP_DIR = input;
96 vEncSample->OUT_DIR = output;
97 vEncSample->DEFAULT_WIDTH = width;
98 vEncSample->DEFAULT_HEIGHT = height;
99 vEncSample->DEFAULT_BITRATE_MODE = bitrateMode;
100 vEncSample->DEFAULT_MAX_BITRATE = bitRate;
101 vEncSample->DEFAULT_FRAME_RATE = 30;
102 vEncSample->SURF_INPUT = surfaceMode;
103 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 2000;
104 vEncSample->enablePTSBasedRateControl = true;
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->ConfigureVideoEncoder());
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_PTS_FUNC_002
115 * @tc.name : VIDEO_HW_ENCODE_PTS_FUNC_002
116 * @tc.desc : function test
117 */
118 HWTEST_F(HwEncApiNdkTest, VIDEO_HW_ENCODE_PTS_FUNC_002, TestSize.Level1)
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 string timeStampFilePath = "/data/test/media/xtscase_04_sqr_buffer.txt";
126 string inputDir = "";
127 string outputDir = "";
128 uint32_t width = 0;
129 uint32_t height = 0;
130 uint32_t bitrateMode = 0;
131 uint32_t bitRate = 0;
132 bool surfaceMode = false;
133 vEncSample->LoadTimeStampData(timeStampFilePath, inputDir, outputDir, width, height,
134 bitrateMode, bitRate, surfaceMode);
135 char *input = new char[1024];
136 char *output = new char[1024];
137 snprintf(input, 1024, "%s", inputDir.c_str());
138 snprintf(output, 1024, "%s", outputDir.c_str());
139 vEncSample->MAXBITE_ENABLE = true;
140 vEncSample->INP_DIR = input;
141 vEncSample->OUT_DIR = output;
142 vEncSample->DEFAULT_WIDTH = width;
143 vEncSample->DEFAULT_HEIGHT = height;
144 vEncSample->DEFAULT_BITRATE_MODE = bitrateMode;
145 vEncSample->DEFAULT_MAX_BITRATE = bitRate;
146 vEncSample->DEFAULT_FRAME_RATE = 30;
147 vEncSample->SURF_INPUT = surfaceMode;
148 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 2000;
149 vEncSample->enablePTSBasedRateControl = true;
150 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
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_HW_ENCODE_PTS_FUNC_003
160 * @tc.name : VIDEO_HW_ENCODE_PTS_FUNC_003
161 * @tc.desc : function test
162 */
163 HWTEST_F(HwEncApiNdkTest, VIDEO_HW_ENCODE_PTS_FUNC_003, TestSize.Level1)
164 {
165 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
166 if (!isSupported) {
167 return;
168 }
169 auto vEncSample = make_unique<VEncAPI11Sample>();
170 string timeStampFilePath = "/data/test/media/xtscase_07_sqr_buffer.txt";
171 string inputDir = "";
172 string outputDir = "";
173 uint32_t width = 0;
174 uint32_t height = 0;
175 uint32_t bitrateMode = 0;
176 uint32_t bitRate = 0;
177 bool surfaceMode = false;
178 vEncSample->LoadTimeStampData(timeStampFilePath, inputDir, outputDir, width, height,
179 bitrateMode, bitRate, surfaceMode);
180 char *input = new char[1024];
181 char *output = new char[1024];
182 snprintf(input, 1024, "%s", inputDir.c_str());
183 snprintf(output, 1024, "%s", outputDir.c_str());
184 vEncSample->MAXBITE_ENABLE = true;
185 vEncSample->INP_DIR = input;
186 vEncSample->OUT_DIR = output;
187 vEncSample->DEFAULT_WIDTH = width;
188 vEncSample->DEFAULT_HEIGHT = height;
189 vEncSample->DEFAULT_BITRATE_MODE = bitrateMode;
190 vEncSample->DEFAULT_MAX_BITRATE = bitRate;
191 vEncSample->DEFAULT_FRAME_RATE = 30;
192 vEncSample->SURF_INPUT = surfaceMode;
193 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 2000;
194 vEncSample->enablePTSBasedRateControl = true;
195 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
196 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
197 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
198 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
199 vEncSample->WaitForEOS();
200 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
201 }
202
203 /**
204 * @tc.number : VIDEO_HW_ENCODE_PTS_FUNC_004
205 * @tc.name : VIDEO_HW_ENCODE_PTS_FUNC_004
206 * @tc.desc : function test
207 */
208 HWTEST_F(HwEncApiNdkTest, VIDEO_HW_ENCODE_PTS_FUNC_004, TestSize.Level1)
209 {
210 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
211 if (!isSupported) {
212 return;
213 }
214 auto vEncSample = make_unique<VEncAPI11Sample>();
215 string timeStampFilePath = "/data/test/media/xtscase_01_sqr_surface.txt";
216 string inputDir = "";
217 string outputDir = "";
218 uint32_t width = 0;
219 uint32_t height = 0;
220 uint32_t bitrateMode = 0;
221 uint32_t bitRate = 0;
222 bool surfaceMode = false;
223 vEncSample->LoadTimeStampData(timeStampFilePath, inputDir, outputDir, width, height,
224 bitrateMode, bitRate, surfaceMode);
225 char *input = new char[1024];
226 char *output = new char[1024];
227 snprintf(input, 1024, "%s", inputDir.c_str());
228 snprintf(output, 1024, "%s", outputDir.c_str());
229 vEncSample->MAXBITE_ENABLE = true;
230 vEncSample->INP_DIR = input;
231 vEncSample->OUT_DIR = output;
232 vEncSample->DEFAULT_WIDTH = width;
233 vEncSample->DEFAULT_HEIGHT = height;
234 vEncSample->DEFAULT_BITRATE_MODE = bitrateMode;
235 vEncSample->DEFAULT_MAX_BITRATE = bitRate;
236 vEncSample->DEFAULT_FRAME_RATE = 30;
237 vEncSample->SURF_INPUT = surfaceMode;
238 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 2000;
239 vEncSample->enablePTSBasedRateControl = true;
240 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
241 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
242 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
243 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
244 vEncSample->WaitForEOS();
245 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
246 }
247
248 /**
249 * @tc.number : VIDEO_HW_ENCODE_PTS_FUNC_005
250 * @tc.name : VIDEO_HW_ENCODE_PTS_FUNC_005
251 * @tc.desc : function test
252 */
253 HWTEST_F(HwEncApiNdkTest, VIDEO_HW_ENCODE_PTS_FUNC_005, TestSize.Level1)
254 {
255 bool isSupported = OH_AVCapability_IsEncoderBitrateModeSupported(g_capEnc, BITRATE_MODE_SQR);
256 if (!isSupported) {
257 return;
258 }
259 auto vEncSample = make_unique<VEncAPI11Sample>();
260 string timeStampFilePath = "/data/test/media/xtscase_04_sqr_surface.txt";
261 string inputDir = "";
262 string outputDir = "";
263 uint32_t width = 0;
264 uint32_t height = 0;
265 uint32_t bitrateMode = 0;
266 uint32_t bitRate = 0;
267 bool surfaceMode = false;
268 vEncSample->LoadTimeStampData(timeStampFilePath, inputDir, outputDir, width, height,
269 bitrateMode, bitRate, surfaceMode);
270 char *input = new char[1024];
271 char *output = new char[1024];
272 snprintf(input, 1024, "%s", inputDir.c_str());
273 snprintf(output, 1024, "%s", outputDir.c_str());
274 vEncSample->MAXBITE_ENABLE = true;
275 vEncSample->INP_DIR = input;
276 vEncSample->OUT_DIR = output;
277 vEncSample->DEFAULT_WIDTH = width;
278 vEncSample->DEFAULT_HEIGHT = height;
279 vEncSample->DEFAULT_BITRATE_MODE = bitrateMode;
280 vEncSample->DEFAULT_MAX_BITRATE = bitRate;
281 vEncSample->DEFAULT_FRAME_RATE = 30;
282 vEncSample->SURF_INPUT = surfaceMode;
283 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 2000;
284 vEncSample->enablePTSBasedRateControl = true;
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->ConfigureVideoEncoder());
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_PTS_FUNC_006
295 * @tc.name : VIDEO_HW_ENCODE_PTS_FUNC_006
296 * @tc.desc : function test
297 */
298 HWTEST_F(HwEncApiNdkTest, VIDEO_HW_ENCODE_PTS_FUNC_006, 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 string timeStampFilePath = "/data/test/media/xtscase_07_sqr_surface.txt";
306 string inputDir = "";
307 string outputDir = "";
308 uint32_t width = 0;
309 uint32_t height = 0;
310 uint32_t bitrateMode = 0;
311 uint32_t bitRate = 0;
312 bool surfaceMode = false;
313 vEncSample->LoadTimeStampData(timeStampFilePath, inputDir, outputDir, width, height,
314 bitrateMode, bitRate, surfaceMode);
315 char *input = new char[1024];
316 char *output = new char[1024];
317 snprintf(input, 1024, "%s", inputDir.c_str());
318 snprintf(output, 1024, "%s", outputDir.c_str());
319 vEncSample->MAXBITE_ENABLE = true;
320 vEncSample->INP_DIR = input;
321 vEncSample->OUT_DIR = output;
322 vEncSample->DEFAULT_WIDTH = width;
323 vEncSample->DEFAULT_HEIGHT = height;
324 vEncSample->DEFAULT_BITRATE_MODE = bitrateMode;
325 vEncSample->DEFAULT_MAX_BITRATE = bitRate;
326 vEncSample->DEFAULT_FRAME_RATE = 30;
327 vEncSample->SURF_INPUT = surfaceMode;
328 vEncSample->DEFAULT_KEY_FRAME_INTERVAL = 2000;
329 vEncSample->enablePTSBasedRateControl = true;
330 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME));
331 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
332 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
333 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
334 vEncSample->WaitForEOS();
335 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
336 }
337 } // namespace