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 #include "gtest/gtest.h"
17 #include "native_avcodec_videoencoder.h"
18 #include "native_averrors.h"
19 #include "videoenc_ndk_sample.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22 #include "native_avcapability.h"
23
24 #define MAX_THREAD 16
25
26 using namespace std;
27 using namespace OHOS;
28 using namespace OHOS::Media;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Media {
33 class HwEncPerfNdkTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 void InputFunc();
40 void OutputFunc();
41 void Release();
42 int32_t Stop();
43
44 protected:
45 OH_AVCapability *cap = nullptr;
46 OH_AVCapability *cap_hevc = nullptr;
47 const string codecMime = "video/avc";
48 const string codecMimeHEVC = "video/hevc";
49 const string codecName;
50 const string codecNameHEVC;
51 const char *inpDir720 = "/data/test/media/1280_720_nv.yuv";
52 const char *inpDir1080 = "/data/test/media/1920_1080_nv.yuv";
53 const char *inpDir2160 = "/data/test/media/3840_2160_nv.yuv";
54 };
55 } // namespace Media
56 } // namespace OHOS
57
SetUpTestCase()58 void HwEncPerfNdkTest::SetUpTestCase()
59 {
60 cap = OH_AVCodec_GetCapabilityByCategory(codecMime.c_str(), true, HARDWARE);
61 codecName = OH_AVCapability_GetName(cap);
62 cap_hevc = OH_AVCodec_GetCapabilityByCategory(codecMimeHEVC.c_str(), true, HARDWARE);
63 codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
64 }
TearDownTestCase()65 void HwEncPerfNdkTest::TearDownTestCase() {}
SetUp()66 void HwEncPerfNdkTest::SetUp() {}
TearDown()67 void HwEncPerfNdkTest::TearDown() {}
68
69 namespace {
70 /**
71 * @tc.number : VIDEO_ENCODE_PERF_0100
72 * @tc.name : OH_VideoEncoder_CreateByMime
73 * @tc.desc : performance test
74 */
75 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0100, TestSize.Level1)
76 {
77 auto vEncSample = make_unique<VEncNdkSample>();
78 vEncSample->INP_DIR = inpDir720;
79 vEncSample->DEFAULT_WIDTH = 1280;
80 vEncSample->DEFAULT_HEIGHT = 720;
81 vEncSample->DEFAULT_FRAME_RATE = 30;
82 vEncSample->DEFAULT_BITRATE = 10000000;
83 vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
84 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
85 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
86 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
87 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
88 vEncSample->WaitForEOS();
89 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
90 }
91
92 /**
93 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0200
94 * @tc.name : perf time,1080P buffer
95 * @tc.desc : performance test
96 */
97 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0200, TestSize.Level1)
98 {
99 auto vEncSample = make_unique<VEncNdkSample>();
100 vEncSample->INP_DIR = inpDir1080;
101 vEncSample->DEFAULT_WIDTH = 1920;
102 vEncSample->DEFAULT_HEIGHT = 1088;
103 vEncSample->DEFAULT_FRAME_RATE = 30;
104 vEncSample->DEFAULT_BITRATE = 20000000;
105 vEncSample->OUT_DIR = "/data/test/media/1920_1080_buffer.h264";
106 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
107 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
108 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
109 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
110 vEncSample->WaitForEOS();
111 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
112 }
113
114 /**
115 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0300
116 * @tc.name : perf time,4K buffer
117 * @tc.desc : performance test
118 */
119 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0300, TestSize.Level1)
120 {
121 auto vEncSample = make_unique<VEncNdkSample>();
122 vEncSample->INP_DIR = inpDir2160;
123 vEncSample->DEFAULT_WIDTH = 3840;
124 vEncSample->DEFAULT_HEIGHT = 2160;
125 vEncSample->DEFAULT_FRAME_RATE = 30;
126 vEncSample->DEFAULT_BITRATE = 30000000;
127 vEncSample->OUT_DIR = "/data/test/media/3840_2160_buffer.h264";
128 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
129 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
130 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
131 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
132 vEncSample->WaitForEOS();
133 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
134 }
135
136 /**
137 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0400
138 * @tc.name : perf time,720P buffer
139 * @tc.desc : performance test
140 */
141 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0400, TestSize.Level1)
142 {
143 auto vEncSample = make_unique<VEncNdkSample>();
144 vEncSample->INP_DIR = inpDir720;
145 vEncSample->DEFAULT_WIDTH = 1280;
146 vEncSample->DEFAULT_HEIGHT = 720;
147 vEncSample->DEFAULT_FRAME_RATE = 60;
148 vEncSample->DEFAULT_BITRATE = 10000000;
149 vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
150 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
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_PERF_BUFFER_0500
160 * @tc.name : perf mmeory,1080P buffer
161 * @tc.desc : performance test
162 */
163 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0500, TestSize.Level1)
164 {
165 auto vEncSample = make_unique<VEncNdkSample>();
166 vEncSample->INP_DIR = inpDir1080;
167 vEncSample->DEFAULT_WIDTH = 1920;
168 vEncSample->DEFAULT_HEIGHT = 1088;
169 vEncSample->DEFAULT_FRAME_RATE = 60;
170 vEncSample->DEFAULT_BITRATE = 20000000;
171 vEncSample->OUT_DIR = "/data/test/media/1920_1080_buffer.h264";
172 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
173 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
174 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
175 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
176 vEncSample->WaitForEOS();
177 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
178 }
179
180 /**
181 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0600
182 * @tc.name : perf memory,4K buffer
183 * @tc.desc : performance test
184 */
185 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0600, TestSize.Level1)
186 {
187 auto vEncSample = make_unique<VEncNdkSample>();
188 vEncSample->INP_DIR = inpDir2160;
189 vEncSample->DEFAULT_WIDTH = 3840;
190 vEncSample->DEFAULT_HEIGHT = 2160;
191 vEncSample->DEFAULT_FRAME_RATE = 60;
192 vEncSample->DEFAULT_BITRATE = 30000000;
193 vEncSample->OUT_DIR = "/data/test/media/3840_2160_buffer.h264";
194 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
195 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
196 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
197 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
198 vEncSample->WaitForEOS();
199 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
200 }
201
202 /**
203 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0700
204 * @tc.name : perf memory,720P buffer
205 * @tc.desc : performance test
206 */
207 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0700, TestSize.Level1)
208 {
209 auto vEncSample = make_unique<VEncNdkSample>();
210 vEncSample->INP_DIR = inpDir720;
211 vEncSample->DEFAULT_WIDTH = 1280;
212 vEncSample->DEFAULT_HEIGHT = 720;
213 vEncSample->DEFAULT_FRAME_RATE = 30;
214 vEncSample->DEFAULT_BITRATE = 10000000;
215 vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
216 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
217 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
218 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
219 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
220 vEncSample->WaitForEOS();
221 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
222 }
223
224 /**
225 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0700
226 * @tc.name : perf memory,720P buffer
227 * @tc.desc : performance test
228 */
229 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0800, TestSize.Level1)
230 {
231 auto vEncSample = make_unique<VEncNdkSample>();
232 vEncSample->INP_DIR = inpDir1080;
233 vEncSample->DEFAULT_WIDTH = 1920;
234 vEncSample->DEFAULT_HEIGHT = 1088;
235 vEncSample->DEFAULT_FRAME_RATE = 30;
236 vEncSample->DEFAULT_BITRATE = 20000000;
237 vEncSample->OUT_DIR = "/data/test/media/1920_1080_buffer.h264";
238 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
239 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
240 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
241 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
242 vEncSample->WaitForEOS();
243 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
244 }
245
246 /**
247 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0900
248 * @tc.name : perf memory,4K buffer
249 * @tc.desc : performance test
250 */
251 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0900, TestSize.Level1)
252 {
253 auto vEncSample = make_unique<VEncNdkSample>();
254 vEncSample->INP_DIR = inpDir2160;
255 vEncSample->DEFAULT_WIDTH = 3840;
256 vEncSample->DEFAULT_HEIGHT = 2160;
257 vEncSample->DEFAULT_FRAME_RATE = 30;
258 vEncSample->DEFAULT_BITRATE = 30000000;
259 vEncSample->OUT_DIR = "/data/test/media/3840_2160_buffer.h264";
260 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
261 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
262 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
263 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
264 vEncSample->WaitForEOS();
265 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
266 }
267
268 /**
269 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0700
270 * @tc.name : perf time,720P buffer
271 * @tc.desc : performance test
272 */
273 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_1000, TestSize.Level1)
274 {
275 auto vEncSample = make_unique<VEncNdkSample>();
276 vEncSample->INP_DIR = inpDir720;
277 vEncSample->DEFAULT_WIDTH = 1280;
278 vEncSample->DEFAULT_HEIGHT = 720;
279 vEncSample->DEFAULT_FRAME_RATE = 30;
280 vEncSample->DEFAULT_BITRATE = 10000000;
281 vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h265";
282 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
283 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
284 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
285 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
286 vEncSample->WaitForEOS();
287 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
288 }
289
290 /**
291 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_1100
292 * @tc.name : perf time,1080P buffer
293 * @tc.desc : performance test
294 */
295 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_1100, TestSize.Level1)
296 {
297 auto vEncSample = make_unique<VEncNdkSample>();
298 vEncSample->INP_DIR = inpDir1080;
299 vEncSample->DEFAULT_WIDTH = 1920;
300 vEncSample->DEFAULT_HEIGHT = 1088;
301 vEncSample->DEFAULT_FRAME_RATE = 60;
302 vEncSample->DEFAULT_BITRATE = 20000000;
303 vEncSample->OUT_DIR = "/data/test/media/1920_1080_buffer.h265";
304 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
305 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
306 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
307 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
308 vEncSample->WaitForEOS();
309 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
310 }
311
312 /**
313 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_1200
314 * @tc.name : perf time,4K buffer
315 * @tc.desc : performance test
316 */
317 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_1200, TestSize.Level1)
318 {
319 auto vEncSample = make_unique<VEncNdkSample>();
320 vEncSample->INP_DIR = inpDir2160;
321 vEncSample->DEFAULT_WIDTH = 3840;
322 vEncSample->DEFAULT_HEIGHT = 2160;
323 vEncSample->DEFAULT_FRAME_RATE = 60;
324 vEncSample->DEFAULT_BITRATE = 30000000;
325 vEncSample->OUT_DIR = "/data/test/media/3840_2160_buffer.h265";
326 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
327 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
328 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
329 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
330 vEncSample->WaitForEOS();
331 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
332 }
333
334 /**
335 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0100
336 * @tc.name : perf time,720P surface
337 * @tc.desc : performance test
338 */
339 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0100, TestSize.Level1)
340 {
341 auto vEncSample = make_unique<VEncNdkSample>();
342 vEncSample->INP_DIR = inpDir720;
343 vEncSample->DEFAULT_WIDTH = 1280;
344 vEncSample->DEFAULT_HEIGHT = 720;
345 vEncSample->DEFAULT_FRAME_RATE = 30;
346 vEncSample->DEFAULT_BITRATE = 10000000;
347 vEncSample->SURFACE_INPUT = true;
348 vEncSample->OUT_DIR = "/data/test/media/1280_720.h264";
349 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
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
357 /**
358 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0200
359 * @tc.name : perf time,1080P surface
360 * @tc.desc : performance test
361 */
362 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0200, TestSize.Level1)
363 {
364 auto vEncSample = make_unique<VEncNdkSample>();
365 vEncSample->INP_DIR = inpDir1080;
366 vEncSample->DEFAULT_WIDTH = 1920;
367 vEncSample->DEFAULT_HEIGHT = 1088;
368 vEncSample->DEFAULT_FRAME_RATE = 30;
369 vEncSample->DEFAULT_BITRATE = 20000000;
370 vEncSample->SURFACE_INPUT = true;
371 vEncSample->OUT_DIR = "/data/test/media/1920_1080.h264";
372 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
373 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
374 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
375 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
376 vEncSample->WaitForEOS();
377 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
378 }
379
380 /**
381 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0300
382 * @tc.name : perf time,4K surface
383 * @tc.desc : performance test
384 */
385 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0300, TestSize.Level1)
386 {
387 auto vEncSample = make_unique<VEncNdkSample>();
388 vEncSample->INP_DIR = inpDir2160;
389 vEncSample->DEFAULT_WIDTH = 3840;
390 vEncSample->DEFAULT_HEIGHT = 2160;
391 vEncSample->DEFAULT_FRAME_RATE = 30;
392 vEncSample->DEFAULT_BITRATE = 30000000;
393 vEncSample->SURFACE_INPUT = true;
394 vEncSample->OUT_DIR = "/data/test/media/3840_2160.h264";
395 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
396 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
397 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
398 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
399 vEncSample->WaitForEOS();
400 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
401 }
402
403 /**
404 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0400
405 * @tc.name : perf time,720P surface
406 * @tc.desc : performance test
407 */
408 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0400, TestSize.Level1)
409 {
410 auto vEncSample = make_unique<VEncNdkSample>();
411 vEncSample->INP_DIR = inpDir720;
412 vEncSample->DEFAULT_WIDTH = 1280;
413 vEncSample->DEFAULT_HEIGHT = 720;
414 vEncSample->DEFAULT_FRAME_RATE = 60;
415 vEncSample->DEFAULT_BITRATE = 10000000;
416 vEncSample->SURFACE_INPUT = true;
417 vEncSample->OUT_DIR = "/data/test/media/1280_720.h265";
418 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
419 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
420 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
421 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
422 vEncSample->WaitForEOS();
423 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
424 }
425
426 /**
427 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0500
428 * @tc.name : perf time,1080P surface
429 * @tc.desc : performance test
430 */
431 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0500, TestSize.Level1)
432 {
433 auto vEncSample = make_unique<VEncNdkSample>();
434 vEncSample->INP_DIR = inpDir1080;
435 vEncSample->DEFAULT_WIDTH = 1920;
436 vEncSample->DEFAULT_HEIGHT = 1088;
437 vEncSample->DEFAULT_FRAME_RATE = 60;
438 vEncSample->DEFAULT_BITRATE = 20000000;
439 vEncSample->SURFACE_INPUT = true;
440 vEncSample->OUT_DIR = "/data/test/media/1920_1080.h265";
441 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
442 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
443 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
444 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
445 vEncSample->WaitForEOS();
446 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
447 }
448
449 /**
450 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0600
451 * @tc.name : perf time,4K surface
452 * @tc.desc : performance test
453 */
454 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0600, TestSize.Level1)
455 {
456 auto vEncSample = make_unique<VEncNdkSample>();
457 vEncSample->INP_DIR = inpDir2160;
458 vEncSample->DEFAULT_WIDTH = 3840;
459 vEncSample->DEFAULT_HEIGHT = 2160;
460 vEncSample->DEFAULT_FRAME_RATE = 60;
461 vEncSample->DEFAULT_BITRATE = 30000000;
462 vEncSample->SURFACE_INPUT = true;
463 vEncSample->OUT_DIR = "/data/test/media/3840_2160.h265";
464 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(CODEC_NAME_AVC));
465 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
466 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
467 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
468 vEncSample->WaitForEOS();
469 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
470 }
471
472 /**
473 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0700
474 * @tc.name : perf time,720P surface
475 * @tc.desc : performance test
476 */
477 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0700, TestSize.Level1)
478 {
479 auto vEncSample = make_unique<VEncNdkSample>();
480 vEncSample->INP_DIR = inpDir720;
481 vEncSample->DEFAULT_WIDTH = 1280;
482 vEncSample->DEFAULT_HEIGHT = 720;
483 vEncSample->DEFAULT_FRAME_RATE = 30;
484 vEncSample->DEFAULT_BITRATE = 10000000;
485 vEncSample->SURFACE_INPUT = true;
486 vEncSample->OUT_DIR = "/data/test/media/1280_720.h264";
487 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
488 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
489 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
490 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
491 vEncSample->WaitForEOS();
492 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
493 }
494
495 /**
496 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0800
497 * @tc.name : perf time,1080P surface
498 * @tc.desc : performance test
499 */
500 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0800, TestSize.Level1)
501 {
502 auto vEncSample = make_unique<VEncNdkSample>();
503 vEncSample->INP_DIR = inpDir1080;
504 vEncSample->DEFAULT_WIDTH = 1920;
505 vEncSample->DEFAULT_HEIGHT = 1088;
506 vEncSample->DEFAULT_FRAME_RATE = 30;
507 vEncSample->DEFAULT_BITRATE = 20000000;
508 vEncSample->SURFACE_INPUT = true;
509 vEncSample->OUT_DIR = "/data/test/media/1920_1080.h264";
510 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
511 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
512 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
513 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
514 vEncSample->WaitForEOS();
515 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
516 }
517
518 /**
519 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0900
520 * @tc.name : perf time,4K surface
521 * @tc.desc : performance test
522 */
523 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0900, TestSize.Level1)
524 {
525 auto vEncSample = make_unique<VEncNdkSample>();
526 vEncSample->INP_DIR = inpDir2160;
527 vEncSample->DEFAULT_WIDTH = 3840;
528 vEncSample->DEFAULT_HEIGHT = 2160;
529 vEncSample->DEFAULT_FRAME_RATE = 30;
530 vEncSample->DEFAULT_BITRATE = 30000000;
531 vEncSample->SURFACE_INPUT = true;
532 vEncSample->OUT_DIR = "/data/test/media/3840_2160.h264";
533 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
534 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
535 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
536 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
537 vEncSample->WaitForEOS();
538 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
539 }
540
541 /**
542 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_1000
543 * @tc.name : perf memory,720p surface
544 * @tc.desc : performance test
545 */
546 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_1000, TestSize.Level1)
547 {
548 auto vEncSample = make_unique<VEncNdkSample>();
549 vEncSample->INP_DIR = inpDir720;
550 vEncSample->DEFAULT_WIDTH = 1280;
551 vEncSample->DEFAULT_HEIGHT = 720;
552 vEncSample->DEFAULT_FRAME_RATE = 60;
553 vEncSample->DEFAULT_BITRATE = 10000000;
554 vEncSample->SURFACE_INPUT = true;
555 vEncSample->OUT_DIR = "/data/test/media/1280_720.h264";
556 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
557 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
558 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
559 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
560 vEncSample->WaitForEOS();
561 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
562 }
563
564 /**
565 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_1100
566 * @tc.name : perf memory,1080P surface
567 * @tc.desc : performance test
568 */
569 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_1100, TestSize.Level1)
570 {
571 auto vEncSample = make_unique<VEncNdkSample>();
572 vEncSample->INP_DIR = inpDir1080;
573 vEncSample->DEFAULT_WIDTH = 1920;
574 vEncSample->DEFAULT_HEIGHT = 1088;
575 vEncSample->DEFAULT_FRAME_RATE = 60;
576 vEncSample->DEFAULT_BITRATE = 20000000;
577 vEncSample->SURFACE_INPUT = true;
578 vEncSample->OUT_DIR = "/data/test/media/1920_1080.h264";
579 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
580 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
581 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
582 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
583 vEncSample->WaitForEOS();
584 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
585 }
586
587 /**
588 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_1200
589 * @tc.name : perf memory,4K surface
590 * @tc.desc : performance test
591 */
592 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_1200, TestSize.Level1)
593 {
594 auto vEncSample = make_unique<VEncNdkSample>();
595 vEncSample->INP_DIR = inpDir2160;
596 vEncSample->DEFAULT_WIDTH = 3840;
597 vEncSample->DEFAULT_HEIGHT = 2160;
598 vEncSample->DEFAULT_FRAME_RATE = 60;
599 vEncSample->DEFAULT_BITRATE = 30000000;
600 vEncSample->SURFACE_INPUT = true;
601 vEncSample->OUT_DIR = "/data/test/media/3840_2160.h264";
602 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(codecNameHEVC));
603 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
604 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
605 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
606 vEncSample->WaitForEOS();
607 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
608 }
609
610 /**
611 * @tc.number : VIDEO_ENCODE_PERF_0100
612 * @tc.name : OH_VideoEncoder_CreateByMime
613 * @tc.desc : performance test
614 */
615 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_0100, TestSize.Level1)
616 {
617 for (int i = 0; i < 2000; i++) {
618 venc_ = OH_VideoEncoder_CreateByMime(codecMime);
619 OH_VideoEncoder_Destroy(venc_);
620 venc_ = nullptr;
621 }
622 }
623
624 /**
625 * @tc.number : VIDEO_ENCODE_PERF_FUNCTION_2200
626 * @tc.name : api test 2000 time
627 * @tc.desc : performance test
628 */
629 HWTEST_F(HwEncPerfNdkTest, VIDEO_ENCODE_PERF_FUNCTION_2200, TestSize.Level1)
630 {
631 for (int i = 0; i < 2000; i++) {
632 auto vEncSample = make_unique<VEncNdkSample>();
633 vEncSample->INP_DIR = inpDir1080;
634 vEncSample->DEFAULT_WIDTH = 1920;
635 vEncSample->DEFAULT_HEIGHT = 1080;
636 vEncSample->DEFAULT_FRAME_RATE = 30;
637 vEncSample->CreateVideoEncoder(CODEC_NAME_AVC);
638 vEncSample->SetVideoEncoderCallback();
639 vEncSample->ConfigureVideoEncoder();
640 vEncSample->testApi();
641 delete vEncSample;
642 cout << i << " ";
643 }
644 }
645 } // namespace