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 "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 {
32 OH_AVCodec *venc_ = NULL;
33 OH_AVCapability *cap = nullptr;
34 constexpr uint32_t CODEC_NAME_SIZE = 128;
35 char g_codecName[CODEC_NAME_SIZE] = {};
36 const char *INP_DIR_720 = "/data/test/media/1280_720_nv.yuv";
37 const char *INP_DIR_1080 = "/data/test/media/1920_1080_nv21.yuv";
38 }
39
40 namespace OHOS {
41 namespace Media {
42 class AvcSwEncPerfNdkTest : 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
SetUpTestCase()56 void AvcSwEncPerfNdkTest::SetUpTestCase()
57 {
58 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, SOFTWARE);
59 const char *tmpCodecName = OH_AVCapability_GetName(cap);
60 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
61 cout << "memcpy failed" << endl;
62 cout << "codecname: " << g_codecName << endl;
63 }
TearDownTestCase()64 void AvcSwEncPerfNdkTest::TearDownTestCase() {}
SetUp()65 void AvcSwEncPerfNdkTest::SetUp() {}
TearDown()66 void AvcSwEncPerfNdkTest::TearDown() {}
67
68 namespace {
69 /**
70 * @tc.number : VIDEO_ENCODE_PERF_0100
71 * @tc.name : OH_VideoEncoder_CreateByMime
72 * @tc.desc : performance test
73 */
74 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0100, TestSize.Level1)
75 {
76 if (strlen(g_codecName) == 0) {
77 return;
78 }
79 auto vEncSample = make_unique<VEncNdkSample>();
80 vEncSample->INP_DIR = INP_DIR_720;
81 vEncSample->DEFAULT_WIDTH = 1280;
82 vEncSample->DEFAULT_HEIGHT = 720;
83 vEncSample->DEFAULT_FRAME_RATE = 30;
84 vEncSample->DEFAULT_BITRATE = 10000000;
85 vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
86 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
87 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
88 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
89 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
90 vEncSample->WaitForEOS();
91 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
92 }
93
94 /**
95 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0200
96 * @tc.name : perf time,1080P buffer
97 * @tc.desc : performance test
98 */
99 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0200, TestSize.Level1)
100 {
101 if (strlen(g_codecName) == 0) {
102 return;
103 }
104 auto vEncSample = make_unique<VEncNdkSample>();
105 vEncSample->INP_DIR = INP_DIR_1080;
106 vEncSample->DEFAULT_WIDTH = 1920;
107 vEncSample->DEFAULT_HEIGHT = 1088;
108 vEncSample->DEFAULT_FRAME_RATE = 30;
109 vEncSample->DEFAULT_BITRATE = 20000000;
110 vEncSample->OUT_DIR = "/data/test/media/1920_1080_buffer.h264";
111 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
112 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
113 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
114 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
115 vEncSample->WaitForEOS();
116 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
117 }
118
119 /**
120 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0300
121 * @tc.name : perf time,720P buffer
122 * @tc.desc : performance test
123 */
124 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0300, TestSize.Level1)
125 {
126 if (strlen(g_codecName) == 0) {
127 return;
128 }
129 auto vEncSample = make_unique<VEncNdkSample>();
130 vEncSample->INP_DIR = INP_DIR_720;
131 vEncSample->DEFAULT_WIDTH = 1280;
132 vEncSample->DEFAULT_HEIGHT = 720;
133 vEncSample->DEFAULT_FRAME_RATE = 60;
134 vEncSample->DEFAULT_BITRATE = 10000000;
135 vEncSample->OUT_DIR = "/data/test/media/1280_720_buffer.h264";
136 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
137 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
138 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
139 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
140 vEncSample->WaitForEOS();
141 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
142 }
143
144 /**
145 * @tc.number : VIDEO_ENCODE_PERF_BUFFER_0400
146 * @tc.name : perf mmeory,1080P buffer
147 * @tc.desc : performance test
148 */
149 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_BUFFER_0400, TestSize.Level1)
150 {
151 if (strlen(g_codecName) == 0) {
152 return;
153 }
154 auto vEncSample = make_unique<VEncNdkSample>();
155 vEncSample->INP_DIR = INP_DIR_1080;
156 vEncSample->DEFAULT_WIDTH = 1920;
157 vEncSample->DEFAULT_HEIGHT = 1088;
158 vEncSample->DEFAULT_FRAME_RATE = 60;
159 vEncSample->DEFAULT_BITRATE = 20000000;
160 vEncSample->OUT_DIR = "/data/test/media/1920_1080_buffer.h264";
161 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
162 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
163 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
164 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
165 vEncSample->WaitForEOS();
166 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
167 }
168
169 /**
170 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0100
171 * @tc.name : perf time,720P surface
172 * @tc.desc : performance test
173 */
174 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0100, TestSize.Level1)
175 {
176 if (strlen(g_codecName) == 0) {
177 return;
178 }
179 auto vEncSample = make_unique<VEncNdkSample>();
180 vEncSample->INP_DIR = INP_DIR_720;
181 vEncSample->DEFAULT_WIDTH = 1280;
182 vEncSample->DEFAULT_HEIGHT = 720;
183 vEncSample->DEFAULT_FRAME_RATE = 30;
184 vEncSample->DEFAULT_BITRATE = 10000000;
185 vEncSample->SURF_INPUT = true;
186 vEncSample->OUT_DIR = "/data/test/media/1280_720.h264";
187 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
188 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
189 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
190 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
191 vEncSample->WaitForEOS();
192 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
193 }
194
195 /**
196 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0200
197 * @tc.name : perf time,1080P surface
198 * @tc.desc : performance test
199 */
200 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0200, TestSize.Level1)
201 {
202 if (strlen(g_codecName) == 0) {
203 return;
204 }
205 auto vEncSample = make_unique<VEncNdkSample>();
206 vEncSample->INP_DIR = INP_DIR_1080;
207 vEncSample->DEFAULT_WIDTH = 1920;
208 vEncSample->DEFAULT_HEIGHT = 1088;
209 vEncSample->DEFAULT_FRAME_RATE = 30;
210 vEncSample->DEFAULT_BITRATE = 20000000;
211 vEncSample->SURF_INPUT = true;
212 vEncSample->OUT_DIR = "/data/test/media/1920_1080.h264";
213 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
214 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
215 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
216 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
217 vEncSample->WaitForEOS();
218 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
219 }
220
221 /**
222 * @tc.number : VIDEO_ENCODE_PERF_SURFACE_0300
223 * @tc.name : perf time,720P surface
224 * @tc.desc : performance test
225 */
226 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0300, TestSize.Level1)
227 {
228 if (strlen(g_codecName) == 0) {
229 return;
230 }
231 auto vEncSample = make_unique<VEncNdkSample>();
232 vEncSample->INP_DIR = INP_DIR_720;
233 vEncSample->DEFAULT_WIDTH = 1280;
234 vEncSample->DEFAULT_HEIGHT = 720;
235 vEncSample->DEFAULT_FRAME_RATE = 60;
236 vEncSample->DEFAULT_BITRATE = 10000000;
237 vEncSample->SURF_INPUT = true;
238 vEncSample->OUT_DIR = "/data/test/media/1280_720.h264";
239 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
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_ENCODE_PERF_SURFACE_0400
249 * @tc.name : perf time,1080P surface
250 * @tc.desc : performance test
251 */
252 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_SURFACE_0400, TestSize.Level1)
253 {
254 if (strlen(g_codecName) == 0) {
255 return;
256 }
257 auto vEncSample = make_unique<VEncNdkSample>();
258 vEncSample->INP_DIR = INP_DIR_1080;
259 vEncSample->DEFAULT_WIDTH = 1920;
260 vEncSample->DEFAULT_HEIGHT = 1088;
261 vEncSample->DEFAULT_FRAME_RATE = 60;
262 vEncSample->DEFAULT_BITRATE = 20000000;
263 vEncSample->SURF_INPUT = true;
264 vEncSample->OUT_DIR = "/data/test/media/1920_1080.h264";
265 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
266 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
267 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
268 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
269 vEncSample->WaitForEOS();
270 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
271 }
272
273 /**
274 * @tc.number : VIDEO_ENCODE_PERF_0100
275 * @tc.name : OH_VideoEncoder_CreateByMime
276 * @tc.desc : performance test
277 */
278 HWTEST_F(AvcSwEncPerfNdkTest, VIDEO_ENCODE_PERF_0100, TestSize.Level1)
279 {
280 if (strlen(g_codecName) == 0) {
281 return;
282 }
283 for (int i = 0; i < 2000; i++) {
284 venc_ = OH_VideoEncoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_AVC);
285 ASSERT_NE(nullptr, venc_);
286 ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Destroy(venc_));
287 venc_ = nullptr;
288 }
289 }
290 } // namespace