1 /*
2 * Copyright (C) 2024 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 <limits>
17 #include "meta/format.h"
18 #include "gtest/gtest.h"
19 #include "native_avcodec_videoencoder.h"
20 #include "native_averrors.h"
21 #include "videoenc_api11_sample.h"
22 #include "native_avcodec_base.h"
23 #include "avcodec_codec_name.h"
24 #include "native_avcapability.h"
25 #include "avcodec_info.h"
26 #include "avcodec_list.h"
27 #include "avcodec_common.h"
28
29 namespace {
30 OH_AVCodec *venc_ = NULL;
31 OH_AVCapability *cap = nullptr;
32 OH_AVCapability *cap_hevc = nullptr;
33 constexpr uint32_t CODEC_NAME_SIZE = 128;
34 constexpr int32_t FRAME_AFTER = 73;
35 constexpr uint32_t COUNT_TWENTY_SEVEN = 27;
36 constexpr uint32_t COUNT_TWENTY_THREE = 23;
37 constexpr uint32_t COUNT_SEVENTEEN = 17;
38 constexpr uint32_t COUNT_THIRTY_SEVEN = 37;
39 constexpr uint32_t COUNT_THIRTY_THREE = 33;
40 constexpr uint32_t COUNT_TWENTY_SIX = 26;
41 constexpr uint32_t COUNT_THIRTY_FIVE = 35;
42 constexpr int32_t MAX_COUNT = 2;
43 char g_codecName[CODEC_NAME_SIZE] = {};
44 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
45 } // namespace
46 namespace OHOS {
47 namespace Media {
48 class HwEncFunc2NdkTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp() override;
53 void TearDown() override;
54 void InputFunc();
55 void OutputFunc();
56 void Release();
57 int32_t Stop();
58 };
59 } // namespace Media
60 } // namespace OHOS
61
62 using namespace std;
63 using namespace OHOS;
64 using namespace OHOS::Media;
65 using namespace testing::ext;
66
67 fileInfo file_640_480_rgba{"/data/test/media/640_480.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 640, 480 };
68 fileInfo file_1280_536_nv21{"/data/test/media/1280_536_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1280, 536 };
69 fileInfo file_1280_720_nv12{"/data/test/media/1280_720_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 720 };
70 fileInfo file_1920_816_rgba{"/data/test/media/1920_816.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 1920, 816 };
71 fileInfo file_1920_1080_nv21{"/data/test/media/1920_1080_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1920, 1080 };
72 fileInfo file_3840_2160_nv12{"/data/test/media/3840_2160_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 3840, 2160 };
73 fileInfo file_1280_720_nv12_10bit{"/data/test/media/1280_720_nv12_10bit.yuv",
74 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, 1280, 720 };
75 fileInfo file_1080_1920_nv12{"/data/test/media/1080_1920_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1080, 1920 };
76 fileInfo file_1280_1280_nv12{"/data/test/media/1280_1280_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 1280 };
77
SetUpTestCase()78 void HwEncFunc2NdkTest::SetUpTestCase()
79 {
80 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
81 const char *tmpCodecName = OH_AVCapability_GetName(cap);
82 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
83 cout << "memcpy failed" << endl;
84 cout << "codecname: " << g_codecName << endl;
85 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
86 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
87 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
88 cout << "memcpy failed" << endl;
89 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
90 }
TearDownTestCase()91 void HwEncFunc2NdkTest::TearDownTestCase() {}
SetUp()92 void HwEncFunc2NdkTest::SetUp() {}
TearDown()93 void HwEncFunc2NdkTest::TearDown()
94 {
95 if (venc_ != NULL) {
96 OH_VideoEncoder_Destroy(venc_);
97 venc_ = nullptr;
98 }
99 }
100 namespace {
101 /**
102 * @tc.number : VIDEO_ENCODE_MULTIFILE_0010
103 * @tc.name : h265 encode config 320_240 surface change 640_480 1280_720 1920_1080
104 * @tc.desc : function test
105 */
106 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0010, TestSize.Level1)
107 {
108 if (!access("/system/lib64/media/", 0)) {
109 auto vEncSample = make_unique<VEncAPI11Sample>();
110 vEncSample->DEFAULT_WIDTH = 320;
111 vEncSample->DEFAULT_HEIGHT = 240;
112 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0010.h265";
113 vEncSample->SURF_INPUT = true;
114 vEncSample->readMultiFiles = true;
115 vEncSample->fileInfos.push_back(file_640_480_rgba);
116 vEncSample->fileInfos.push_back(file_1280_720_nv12);
117 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
118 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
119 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
120 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
121 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
122 vEncSample->WaitForEOS();
123 }
124 }
125
126 /**
127 * @tc.number : VIDEO_ENCODE_MULTIFILE_0020
128 * @tc.name : h265 encode config 1280_720 surface change 640_480 1280_720 1920_1080
129 * @tc.desc : function test
130 */
131 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0020, TestSize.Level1)
132 {
133 if (!access("/system/lib64/media/", 0)) {
134 auto vEncSample = make_unique<VEncAPI11Sample>();
135 vEncSample->DEFAULT_WIDTH = 1280;
136 vEncSample->DEFAULT_HEIGHT = 720;
137 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0020.h265";
138 vEncSample->SURF_INPUT = true;
139 vEncSample->readMultiFiles = true;
140 vEncSample->fileInfos.push_back(file_640_480_rgba);
141 vEncSample->fileInfos.push_back(file_1280_720_nv12);
142 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
143 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
144 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
145 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
146 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
147 vEncSample->WaitForEOS();
148 }
149 }
150
151 /**
152 * @tc.number : VIDEO_ENCODE_MULTIFILE_0030
153 * @tc.name : h265 encode config 3840_2160 surface change 640_480 1280_536 1280_720 1920_816 1920_1080 3840_2160
154 * @tc.desc : function test
155 */
156 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0030, TestSize.Level0)
157 {
158 if (!access("/system/lib64/media/", 0)) {
159 auto vEncSample = make_unique<VEncAPI11Sample>();
160 vEncSample->DEFAULT_WIDTH = 3840;
161 vEncSample->DEFAULT_HEIGHT = 2160;
162 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0030.h265";
163 vEncSample->SURF_INPUT = true;
164 vEncSample->readMultiFiles = true;
165 vEncSample->fileInfos.push_back(file_640_480_rgba);
166 vEncSample->fileInfos.push_back(file_1280_536_nv21);
167 vEncSample->fileInfos.push_back(file_1280_720_nv12);
168 vEncSample->fileInfos.push_back(file_1920_816_rgba);
169 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
170 vEncSample->fileInfos.push_back(file_3840_2160_nv12);
171 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
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 }
177 }
178
179 /**
180 * @tc.number : VIDEO_ENCODE_MULTIFILE_0040
181 * @tc.name : h265 encode config 1920_1080 surface change 1920_1080 1080_1920 1280_1280
182 * @tc.desc : function test
183 */
184 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0040, TestSize.Level1)
185 {
186 if (!access("/system/lib64/media/", 0)) {
187 auto vEncSample = make_unique<VEncAPI11Sample>();
188 vEncSample->DEFAULT_WIDTH = 1920;
189 vEncSample->DEFAULT_HEIGHT = 1080;
190 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0040.h265";
191 vEncSample->SURF_INPUT = true;
192 vEncSample->readMultiFiles = true;
193 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
194 vEncSample->fileInfos.push_back(file_1080_1920_nv12);
195 vEncSample->fileInfos.push_back(file_1280_1280_nv12);
196 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
197 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
198 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
199 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
200 vEncSample->WaitForEOS();
201 }
202 }
203
204 /**
205 * @tc.number : VIDEO_ENCODE_MULTIFILE_0050
206 * @tc.name : h264 encode config 320_240 surface change 640_480 1280_720 1920_1080
207 * @tc.desc : function test
208 */
209 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0050, TestSize.Level1)
210 {
211 if (!access("/system/lib64/media/", 0)) {
212 auto vEncSample = make_unique<VEncAPI11Sample>();
213 vEncSample->DEFAULT_WIDTH = 320;
214 vEncSample->DEFAULT_HEIGHT = 240;
215 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0050.h264";
216 vEncSample->SURF_INPUT = true;
217 vEncSample->readMultiFiles = true;
218 vEncSample->fileInfos.push_back(file_640_480_rgba);
219 vEncSample->fileInfos.push_back(file_1280_720_nv12);
220 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
221 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
222 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
223 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
224 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
225 vEncSample->WaitForEOS();
226 }
227 }
228
229 /**
230 * @tc.number : VIDEO_ENCODE_MULTIFILE_0060
231 * @tc.name : h264 encode config 1280_720 surface change 640_480 1280_720 1920_1080
232 * @tc.desc : function test
233 */
234 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0060, TestSize.Level1)
235 {
236 if (!access("/system/lib64/media/", 0)) {
237 auto vEncSample = make_unique<VEncAPI11Sample>();
238 vEncSample->DEFAULT_WIDTH = 1280;
239 vEncSample->DEFAULT_HEIGHT = 720;
240 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0060.h264";
241 vEncSample->SURF_INPUT = true;
242 vEncSample->readMultiFiles = true;
243 vEncSample->fileInfos.push_back(file_640_480_rgba);
244 vEncSample->fileInfos.push_back(file_1280_720_nv12);
245 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
246 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
247 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
248 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
249 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
250 vEncSample->WaitForEOS();
251 }
252 }
253
254 /**
255 * @tc.number : VIDEO_ENCODE_MULTIFILE_0070
256 * @tc.name : h264 encode config 3840_2160 surface change 640_480 1280_536 1280_720 1920_816 1920_1080 3840_2160
257 * @tc.desc : function test
258 */
259 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0070, TestSize.Level0)
260 {
261 if (!access("/system/lib64/media/", 0)) {
262 auto vEncSample = make_unique<VEncAPI11Sample>();
263 vEncSample->DEFAULT_WIDTH = 3840;
264 vEncSample->DEFAULT_HEIGHT = 2160;
265 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0070.h264";
266 vEncSample->SURF_INPUT = true;
267 vEncSample->readMultiFiles = true;
268 vEncSample->fileInfos.push_back(file_640_480_rgba);
269 vEncSample->fileInfos.push_back(file_1280_536_nv21);
270 vEncSample->fileInfos.push_back(file_1280_720_nv12);
271 vEncSample->fileInfos.push_back(file_1920_816_rgba);
272 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
273 vEncSample->fileInfos.push_back(file_3840_2160_nv12);
274 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
275 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
276 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
277 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
278 vEncSample->WaitForEOS();
279 }
280 }
281
282 /**
283 * @tc.number : VIDEO_ENCODE_MULTIFILE_0080
284 * @tc.name : h264 encode config 1920_1080 surface change 1920_1080 1080_1920 1280_1280
285 * @tc.desc : function test
286 */
287 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0080, TestSize.Level1)
288 {
289 if (!access("/system/lib64/media/", 0)) {
290 auto vEncSample = make_unique<VEncAPI11Sample>();
291 vEncSample->DEFAULT_WIDTH = 1920;
292 vEncSample->DEFAULT_HEIGHT = 1080;
293 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0080.h264";
294 vEncSample->SURF_INPUT = true;
295 vEncSample->readMultiFiles = true;
296 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
297 vEncSample->fileInfos.push_back(file_1080_1920_nv12);
298 vEncSample->fileInfos.push_back(file_1280_1280_nv12);
299 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
300 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
301 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
302 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
303 vEncSample->WaitForEOS();
304 }
305 }
306
307 /**
308 * @tc.number : VIDEO_ENCODE_MULTIFILE_0090
309 * @tc.name : config main10 set format 8bit surface send 8bit yuv
310 * @tc.desc : function test
311 */
312 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0090, TestSize.Level1)
313 {
314 if (!access("/system/lib64/media/", 0)) {
315 auto vEncSample = make_unique<VEncAPI11Sample>();
316 vEncSample->DEFAULT_WIDTH = 3840;
317 vEncSample->DEFAULT_HEIGHT = 2160;
318 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0090.h265";
319 vEncSample->SURF_INPUT = true;
320 vEncSample->readMultiFiles = true;
321 vEncSample->configMain10 = true;
322 vEncSample->setFormat8Bit = true;
323 vEncSample->fileInfos.push_back(file_1280_720_nv12);
324 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_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 }
330 }
331
332 /**
333 * @tc.number : VIDEO_ENCODE_MULTIFILE_0100
334 * @tc.name : config main set format 10bit surface send 10bit yuv
335 * @tc.desc : function test
336 */
337 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0100, TestSize.Level1)
338 {
339 if (!access("/system/lib64/media/", 0)) {
340 auto vEncSample = make_unique<VEncAPI11Sample>();
341 vEncSample->DEFAULT_WIDTH = 3840;
342 vEncSample->DEFAULT_HEIGHT = 2160;
343 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0100.h265";
344 vEncSample->SURF_INPUT = true;
345 vEncSample->readMultiFiles = true;
346 vEncSample->configMain = true;
347 vEncSample->setFormat10Bit = true;
348 vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
349 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
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 }
355 }
356
357 /**
358 * @tc.number : VIDEO_ENCODE_MULTIFILE_0110
359 * @tc.name : Not supported pixelFormat rgbx
360 * @tc.desc : function test
361 */
362 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0110, TestSize.Level1)
363 {
364 if (!access("/system/lib64/media/", 0)) {
365 auto vEncSample = make_unique<VEncAPI11Sample>();
366 vEncSample->DEFAULT_WIDTH = 3840;
367 vEncSample->DEFAULT_HEIGHT = 2160;
368 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0110.h265";
369 vEncSample->SURF_INPUT = true;
370 vEncSample->readMultiFiles = true;
371 vEncSample->setFormatRbgx = true;
372 vEncSample->fileInfos.push_back(file_640_480_rgba);
373 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
374 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
375 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
376 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
377 vEncSample->WaitForEOS();
378 }
379 }
380
381 /**
382 * @tc.number : VIDEO_ENCODE_MULTIFILE_0120
383 * @tc.name : config main set format 8bit send 10bit yuv
384 * @tc.desc : function test
385 */
386 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0120, TestSize.Level1)
387 {
388 if (!access("/system/lib64/media/", 0)) {
389 auto vEncSample = make_unique<VEncAPI11Sample>();
390 vEncSample->DEFAULT_WIDTH = 3840;
391 vEncSample->DEFAULT_HEIGHT = 2160;
392 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0120.h265";
393 vEncSample->SURF_INPUT = true;
394 vEncSample->readMultiFiles = true;
395 vEncSample->configMain = true;
396 vEncSample->setFormat8Bit = true;
397 vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
398 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
399 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
400 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
401 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
402 vEncSample->WaitForEOS();
403 }
404 }
405
406 /**
407 * @tc.number : VIDEO_ENCODE_MULTIFILE_0130
408 * @tc.name : config main10 set format 10bit send 8bit yuv
409 * @tc.desc : function test
410 */
411 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0130, TestSize.Level1)
412 {
413 if (!access("/system/lib64/media/", 0)) {
414 auto vEncSample = make_unique<VEncAPI11Sample>();
415 vEncSample->DEFAULT_WIDTH = 3840;
416 vEncSample->DEFAULT_HEIGHT = 2160;
417 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0130.h265";
418 vEncSample->SURF_INPUT = true;
419 vEncSample->readMultiFiles = true;
420 vEncSample->configMain10 = true;
421 vEncSample->setFormat10Bit = true;
422 vEncSample->fileInfos.push_back(file_1280_720_nv12);
423 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
424 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
425 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
426 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
427 vEncSample->WaitForEOS();
428 }
429 }
430
431 /**
432 * @tc.number : VIDEO_ENCODE_MULTIFILE_0140
433 * @tc.name : config main10 set format 8bit send 10bit yuv
434 * @tc.desc : function test
435 */
436 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0140, TestSize.Level1)
437 {
438 if (!access("/system/lib64/media/", 0)) {
439 auto vEncSample = make_unique<VEncAPI11Sample>();
440 vEncSample->DEFAULT_WIDTH = 3840;
441 vEncSample->DEFAULT_HEIGHT = 2160;
442 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0140.h265";
443 vEncSample->SURF_INPUT = true;
444 vEncSample->readMultiFiles = true;
445 vEncSample->configMain10 = true;
446 vEncSample->setFormat8Bit = true;
447 vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
448 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
449 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
450 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
451 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
452 vEncSample->WaitForEOS();
453 }
454 }
455
456 /**
457 * @tc.number : VIDEO_ENCODE_MULTIFILE_0150
458 * @tc.name : config main10 set format 10bit send 8bit yuv
459 * @tc.desc : function test
460 */
461 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0150, TestSize.Level1)
462 {
463 if (!access("/system/lib64/media/", 0)) {
464 auto vEncSample = make_unique<VEncAPI11Sample>();
465 vEncSample->DEFAULT_WIDTH = 3840;
466 vEncSample->DEFAULT_HEIGHT = 2160;
467 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0150.h265";
468 vEncSample->SURF_INPUT = true;
469 vEncSample->readMultiFiles = true;
470 vEncSample->configMain10 = true;
471 vEncSample->setFormat10Bit = true;
472 vEncSample->fileInfos.push_back(file_1280_720_nv12);
473 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
474 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
475 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
476 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
477 vEncSample->WaitForEOS();
478 }
479 }
480
481 /**
482 * @tc.number : VIDEO_ENCODE_REPEAT_0100
483 * @tc.name : set frame after 0
484 * @tc.desc : api test
485 */
486 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_0100, TestSize.Level0)
487 {
488 auto vEncSample = make_unique<VEncAPI11Sample>();
489 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
490 vEncSample->DEFAULT_WIDTH = 1280;
491 vEncSample->DEFAULT_HEIGHT = 720;
492 vEncSample->DEFAULT_BITRATE_MODE = CBR;
493 vEncSample->SURF_INPUT = true;
494 vEncSample->enableRepeat = true;
495 vEncSample->setMaxCount = true;
496 vEncSample->DEFAULT_FRAME_AFTER = 0;
497 vEncSample->DEFAULT_MAX_COUNT = -1;
498 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
499 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
500 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
501 }
502
503 /**
504 * @tc.number : VIDEO_ENCODE_REPEAT_0200
505 * @tc.name : set frame after -1
506 * @tc.desc : api test
507 */
508 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_0200, TestSize.Level1)
509 {
510 auto vEncSample = make_unique<VEncAPI11Sample>();
511 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
512 vEncSample->DEFAULT_WIDTH = 1280;
513 vEncSample->DEFAULT_HEIGHT = 720;
514 vEncSample->DEFAULT_BITRATE_MODE = CBR;
515 vEncSample->SURF_INPUT = true;
516 vEncSample->enableRepeat = true;
517 vEncSample->setMaxCount = true;
518 vEncSample->DEFAULT_FRAME_AFTER = -1;
519 vEncSample->DEFAULT_MAX_COUNT = -1;
520 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
521 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
522 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
523 }
524
525 /**
526 * @tc.number : VIDEO_ENCODE_REPEAT_0300
527 * @tc.name : set max count 0
528 * @tc.desc : api test
529 */
530 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_0300, TestSize.Level1)
531 {
532 auto vEncSample = make_unique<VEncAPI11Sample>();
533 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
534 vEncSample->DEFAULT_WIDTH = 1280;
535 vEncSample->DEFAULT_HEIGHT = 720;
536 vEncSample->DEFAULT_BITRATE_MODE = CBR;
537 vEncSample->SURF_INPUT = true;
538 vEncSample->enableRepeat = true;
539 vEncSample->setMaxCount = true;
540 vEncSample->DEFAULT_FRAME_AFTER = 1;
541 vEncSample->DEFAULT_MAX_COUNT = 0;
542 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
543 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
544 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
545 }
546
547 /**
548 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0100
549 * @tc.name : repeat surface h264 encode send eos,max count -1,frame after 73ms
550 * @tc.desc : function test
551 */
552 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0100, TestSize.Level0)
553 {
554 auto vEncSample = make_unique<VEncAPI11Sample>();
555 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
556 vEncSample->DEFAULT_WIDTH = 1280;
557 vEncSample->DEFAULT_HEIGHT = 720;
558 vEncSample->DEFAULT_BITRATE_MODE = CBR;
559 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0100.h264";
560 vEncSample->SURF_INPUT = true;
561 vEncSample->enableRepeat = true;
562 vEncSample->enableSeekEos = true;
563 vEncSample->setMaxCount = true;
564 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
565 vEncSample->DEFAULT_MAX_COUNT = -1;
566 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
567 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
568 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
569 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
570 vEncSample->WaitForEOS();
571 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
572 cout << "outCount: " << vEncSample->outCount << endl;
573 EXPECT_LE(vEncSample->outCount, COUNT_TWENTY_SEVEN);
574 EXPECT_GE(vEncSample->outCount, COUNT_TWENTY_THREE);
575 }
576
577 /**
578 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0200
579 * @tc.name : repeat surface h264 encode send eos,max count 2,frame after 73ms
580 * @tc.desc : function test
581 */
582 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0200, TestSize.Level0)
583 {
584 auto vEncSample = make_unique<VEncAPI11Sample>();
585 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
586 vEncSample->DEFAULT_WIDTH = 1280;
587 vEncSample->DEFAULT_HEIGHT = 720;
588 vEncSample->DEFAULT_BITRATE_MODE = CBR;
589 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0200.h264";
590 vEncSample->SURF_INPUT = true;
591 vEncSample->enableSeekEos = true;
592 vEncSample->enableRepeat = true;
593 vEncSample->setMaxCount = true;
594 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
595 vEncSample->DEFAULT_MAX_COUNT = MAX_COUNT;
596 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
597 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
598 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
599 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
600 vEncSample->WaitForEOS();
601 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
602 cout << "outCount: " << vEncSample->outCount << endl;
603 ASSERT_EQ(COUNT_SEVENTEEN, vEncSample->outCount);
604 }
605
606 /**
607 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0300
608 * @tc.name : repeat surface h264 encode send frame,max count -1,frame after 73ms
609 * @tc.desc : function test
610 */
611 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0300, TestSize.Level0)
612 {
613 auto vEncSample = make_unique<VEncAPI11Sample>();
614 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
615 vEncSample->DEFAULT_WIDTH = 1280;
616 vEncSample->DEFAULT_HEIGHT = 720;
617 vEncSample->DEFAULT_BITRATE_MODE = CBR;
618 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0300.h264";
619 vEncSample->SURF_INPUT = true;
620 vEncSample->enableRepeat = true;
621 vEncSample->setMaxCount = true;
622 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
623 vEncSample->DEFAULT_MAX_COUNT = -1;
624 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
625 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
626 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
627 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
628 vEncSample->WaitForEOS();
629 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
630 cout << "outCount: " << vEncSample->outCount << endl;
631 EXPECT_LE(vEncSample->outCount, COUNT_THIRTY_SEVEN);
632 EXPECT_GE(vEncSample->outCount, COUNT_THIRTY_THREE);
633 }
634
635 /**
636 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0400
637 * @tc.name : repeat surface h264 encode send frame,max count 1,frame after 73ms
638 * @tc.desc : function test
639 */
640 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0400, TestSize.Level0)
641 {
642 auto vEncSample = make_unique<VEncAPI11Sample>();
643 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
644 vEncSample->DEFAULT_WIDTH = 1280;
645 vEncSample->DEFAULT_HEIGHT = 720;
646 vEncSample->DEFAULT_BITRATE_MODE = CBR;
647 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0400.h264";
648 vEncSample->SURF_INPUT = true;
649 vEncSample->enableRepeat = true;
650 vEncSample->setMaxCount = true;
651 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
652 vEncSample->DEFAULT_MAX_COUNT = 1;
653 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
654 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
655 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
656 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
657 vEncSample->WaitForEOS();
658 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
659 cout << "outCount: " << vEncSample->outCount << endl;
660 ASSERT_EQ(COUNT_TWENTY_SIX, vEncSample->outCount);
661 }
662
663 /**
664 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0500
665 * @tc.name : repeat surface h265 encode send eos,max count -1,frame after 73ms
666 * @tc.desc : function test
667 */
668 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0500, TestSize.Level0)
669 {
670 auto vEncSample = make_unique<VEncAPI11Sample>();
671 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
672 vEncSample->DEFAULT_WIDTH = 1280;
673 vEncSample->DEFAULT_HEIGHT = 720;
674 vEncSample->DEFAULT_BITRATE_MODE = CBR;
675 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0500.h264";
676 vEncSample->SURF_INPUT = true;
677 vEncSample->enableRepeat = true;
678 vEncSample->enableSeekEos = true;
679 vEncSample->setMaxCount = true;
680 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
681 vEncSample->DEFAULT_MAX_COUNT = -1;
682 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
683 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
684 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
685 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
686 vEncSample->WaitForEOS();
687 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
688 cout << "outCount: " << vEncSample->outCount << endl;
689 EXPECT_LE(vEncSample->outCount, COUNT_TWENTY_SEVEN);
690 EXPECT_GE(vEncSample->outCount, COUNT_TWENTY_THREE);
691 }
692
693 /**
694 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0600
695 * @tc.name : repeat surface h265 encode send eos,max count 2,frame after 73ms
696 * @tc.desc : function test
697 */
698 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0600, TestSize.Level0)
699 {
700 auto vEncSample = make_unique<VEncAPI11Sample>();
701 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
702 vEncSample->DEFAULT_WIDTH = 1280;
703 vEncSample->DEFAULT_HEIGHT = 720;
704 vEncSample->DEFAULT_BITRATE_MODE = CBR;
705 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0600.h264";
706 vEncSample->SURF_INPUT = true;
707 vEncSample->enableSeekEos = true;
708 vEncSample->enableRepeat = true;
709 vEncSample->setMaxCount = true;
710 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
711 vEncSample->DEFAULT_MAX_COUNT = MAX_COUNT;
712 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
713 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
714 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
715 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
716 vEncSample->WaitForEOS();
717 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
718 cout << "outCount: " << vEncSample->outCount << endl;
719 ASSERT_EQ(COUNT_SEVENTEEN, vEncSample->outCount);
720 }
721
722 /**
723 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0700
724 * @tc.name : repeat surface h265 encode send frame,max count -1,frame after 73ms
725 * @tc.desc : function test
726 */
727 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0700, TestSize.Level0)
728 {
729 auto vEncSample = make_unique<VEncAPI11Sample>();
730 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
731 vEncSample->DEFAULT_WIDTH = 1280;
732 vEncSample->DEFAULT_HEIGHT = 720;
733 vEncSample->DEFAULT_BITRATE_MODE = CBR;
734 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0700.h264";
735 vEncSample->SURF_INPUT = true;
736 vEncSample->enableRepeat = true;
737 vEncSample->setMaxCount = true;
738 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
739 vEncSample->DEFAULT_MAX_COUNT = -1;
740 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
741 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
742 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
743 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
744 vEncSample->WaitForEOS();
745 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
746 cout << "outCount: " << vEncSample->outCount << endl;
747 EXPECT_LE(vEncSample->outCount, COUNT_THIRTY_SEVEN);
748 EXPECT_GE(vEncSample->outCount, COUNT_THIRTY_THREE);
749 }
750
751 /**
752 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0800
753 * @tc.name : repeat surface h265 encode send frame,max count 1,frame after 73ms
754 * @tc.desc : function test
755 */
756 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0800, TestSize.Level0)
757 {
758 auto vEncSample = make_unique<VEncAPI11Sample>();
759 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
760 vEncSample->DEFAULT_WIDTH = 1280;
761 vEncSample->DEFAULT_HEIGHT = 720;
762 vEncSample->DEFAULT_BITRATE_MODE = CBR;
763 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0800.h264";
764 vEncSample->SURF_INPUT = true;
765 vEncSample->enableRepeat = true;
766 vEncSample->setMaxCount = true;
767 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
768 vEncSample->DEFAULT_MAX_COUNT = 1;
769 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
770 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
771 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
772 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
773 vEncSample->WaitForEOS();
774 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
775 cout << "outCount: " << vEncSample->outCount << endl;
776 ASSERT_EQ(COUNT_TWENTY_SIX, vEncSample->outCount);
777 }
778
779 /**
780 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0900
781 * @tc.name : repeat surface h265 encode send frame,frame after 73ms
782 * @tc.desc : function test
783 */
784 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0900, TestSize.Level0)
785 {
786 auto vEncSample = make_unique<VEncAPI11Sample>();
787 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
788 vEncSample->DEFAULT_WIDTH = 1280;
789 vEncSample->DEFAULT_HEIGHT = 720;
790 vEncSample->DEFAULT_BITRATE_MODE = CBR;
791 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0900.h264";
792 vEncSample->SURF_INPUT = true;
793 vEncSample->enableRepeat = true;
794 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
795 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
796 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
797 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
798 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
799 vEncSample->WaitForEOS();
800 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
801 cout << "outCount: " << vEncSample->outCount << endl;
802 ASSERT_EQ(COUNT_THIRTY_FIVE, vEncSample->outCount);
803 }
804
805 /**
806 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_1000
807 * @tc.name : repeat surface h264 encode send frame,frame after 73ms
808 * @tc.desc : function test
809 */
810 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_1000, TestSize.Level0)
811 {
812 auto vEncSample = make_unique<VEncAPI11Sample>();
813 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
814 vEncSample->DEFAULT_WIDTH = 1280;
815 vEncSample->DEFAULT_HEIGHT = 720;
816 vEncSample->DEFAULT_BITRATE_MODE = CBR;
817 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_1000.h264";
818 vEncSample->SURF_INPUT = true;
819 vEncSample->enableRepeat = true;
820 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
821 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
822 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
823 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
824 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
825 vEncSample->WaitForEOS();
826 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
827 cout << "outCount: " << vEncSample->outCount << endl;
828 ASSERT_EQ(COUNT_THIRTY_FIVE, vEncSample->outCount);
829 }
830 } // namespace