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