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 using namespace std;
30 using namespace OHOS;
31 using namespace OHOS::Media;
32 using namespace testing::ext;
33 namespace {
34 OH_AVCodec *venc_ = NULL;
35 OH_AVCapability *cap = nullptr;
36 OH_AVCapability *cap_hevc = nullptr;
37 constexpr uint32_t CODEC_NAME_SIZE = 128;
38 constexpr int32_t FRAME_AFTER = 73;
39 constexpr uint32_t COUNT_TWENTY_SEVEN = 27;
40 constexpr uint32_t COUNT_TWENTY_THREE = 23;
41 constexpr uint32_t COUNT_SEVENTEEN = 17;
42 constexpr uint32_t COUNT_THIRTY_SEVEN = 37;
43 constexpr uint32_t COUNT_THIRTY_THREE = 33;
44 constexpr uint32_t COUNT_TWENTY_SIX = 26;
45 constexpr uint32_t COUNT_THIRTY_FIVE = 35;
46 constexpr int32_t MAX_COUNT = 2;
47 char g_codecName[CODEC_NAME_SIZE] = {};
48 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
49
50 fileInfo file_640_480_rgba{"/data/test/media/640_480.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 640, 480 };
51 fileInfo file_1280_536_nv21{"/data/test/media/1280_536_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1280, 536 };
52 fileInfo file_1280_720_nv12{"/data/test/media/1280_720_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 720 };
53 fileInfo file_1920_816_rgba{"/data/test/media/1920_816.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 1920, 816 };
54 fileInfo file_1920_1080_nv21{"/data/test/media/1920_1080_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1920, 1080 };
55 fileInfo file_3840_2160_nv12{"/data/test/media/3840_2160_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 3840, 2160 };
56 fileInfo file_1280_720_nv12_10bit{"/data/test/media/1280_720_nv12_10bit.yuv",
57 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, 1280, 720 };
58 fileInfo file_1920_1088_nv12_10bit{"/data/test/media/1920_1088_nv12_10bit.yuv",
59 NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, 1920, 1088 };
60 fileInfo file_1080_1920_nv12{"/data/test/media/1080_1920_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1080, 1920 };
61 fileInfo file_1280_1280_nv12{"/data/test/media/1280_1280_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 1280 };
62 } // namespace
63 namespace OHOS {
64 namespace Media {
65 class HwEncFunc2NdkTest : public testing::Test {
66 public:
67 static void SetUpTestCase();
68 static void TearDownTestCase();
69 void SetUp() override;
70 void TearDown() override;
71 void InputFunc();
72 void OutputFunc();
73 void Release();
74 int32_t Stop();
75 };
76 } // namespace Media
77 } // namespace OHOS
78
SetUpTestCase()79 void HwEncFunc2NdkTest::SetUpTestCase()
80 {
81 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
82 const char *tmpCodecName = OH_AVCapability_GetName(cap);
83 if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
84 cout << "memcpy failed" << endl;
85 cout << "codecname: " << g_codecName << endl;
86 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
87 const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
88 if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
89 cout << "memcpy failed" << endl;
90 cout << "codecname_hevc: " << g_codecNameHEVC << endl;
91 }
TearDownTestCase()92 void HwEncFunc2NdkTest::TearDownTestCase() {}
SetUp()93 void HwEncFunc2NdkTest::SetUp() {}
TearDown()94 void HwEncFunc2NdkTest::TearDown()
95 {
96 if (venc_ != NULL) {
97 OH_VideoEncoder_Destroy(venc_);
98 venc_ = nullptr;
99 }
100 }
101 namespace {
IsSupportRgba1010102Format()102 bool IsSupportRgba1010102Format()
103 {
104 const int32_t *pixelFormat = nullptr;
105 uint32_t pixelFormatNum = 0;
106 OH_AVCapability *capability = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
107 if (capability == nullptr) {
108 return false;
109 }
110 int32_t ret = OH_AVCapability_GetVideoSupportedPixelFormats(capability, &pixelFormat, &pixelFormatNum);
111 if (pixelFormat == nullptr || pixelFormatNum == 0 || ret != AV_ERR_OK) {
112 return false;
113 }
114 for (int i = 0; i < pixelFormatNum; i++) {
115 if (pixelFormat[i] == static_cast<int32_t>(AV_PIXEL_FORMAT_RGBA1010102)) {
116 return true;
117 }
118 }
119 return false;
120 }
121 /**
122 * @tc.number : VIDEO_ENCODE_MULTIFILE_0010
123 * @tc.name : h265 encode config 320_240 surface change 640_480 1280_720 1920_1080
124 * @tc.desc : function test
125 */
126 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0010, TestSize.Level1)
127 {
128 if (!access("/system/lib64/media/", 0)) {
129 auto vEncSample = make_unique<VEncAPI11Sample>();
130 vEncSample->DEFAULT_WIDTH = 320;
131 vEncSample->DEFAULT_HEIGHT = 240;
132 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0010.h265";
133 vEncSample->SURF_INPUT = true;
134 vEncSample->readMultiFiles = true;
135 vEncSample->fileInfos.push_back(file_640_480_rgba);
136 vEncSample->fileInfos.push_back(file_1280_720_nv12);
137 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
138 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
139 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
140 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
141 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
142 vEncSample->WaitForEOS();
143 }
144 }
145
146 /**
147 * @tc.number : VIDEO_ENCODE_MULTIFILE_0020
148 * @tc.name : h265 encode config 1280_720 surface change 640_480 1280_720 1920_1080
149 * @tc.desc : function test
150 */
151 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0020, TestSize.Level1)
152 {
153 if (!access("/system/lib64/media/", 0)) {
154 auto vEncSample = make_unique<VEncAPI11Sample>();
155 vEncSample->DEFAULT_WIDTH = 1280;
156 vEncSample->DEFAULT_HEIGHT = 720;
157 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0020.h265";
158 vEncSample->SURF_INPUT = true;
159 vEncSample->readMultiFiles = true;
160 vEncSample->fileInfos.push_back(file_640_480_rgba);
161 vEncSample->fileInfos.push_back(file_1280_720_nv12);
162 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
163 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
164 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
165 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
166 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
167 vEncSample->WaitForEOS();
168 }
169 }
170
171 /**
172 * @tc.number : VIDEO_ENCODE_MULTIFILE_0030
173 * @tc.name : h265 encode config 3840_2160 surface change 640_480 1280_536 1280_720 1920_816 1920_1080 3840_2160
174 * @tc.desc : function test
175 */
176 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0030, TestSize.Level0)
177 {
178 if (!access("/system/lib64/media/", 0)) {
179 auto vEncSample = make_unique<VEncAPI11Sample>();
180 vEncSample->DEFAULT_WIDTH = 3840;
181 vEncSample->DEFAULT_HEIGHT = 2160;
182 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0030.h265";
183 vEncSample->SURF_INPUT = true;
184 vEncSample->readMultiFiles = true;
185 vEncSample->fileInfos.push_back(file_640_480_rgba);
186 vEncSample->fileInfos.push_back(file_1280_536_nv21);
187 vEncSample->fileInfos.push_back(file_1280_720_nv12);
188 vEncSample->fileInfos.push_back(file_1920_816_rgba);
189 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
190 vEncSample->fileInfos.push_back(file_3840_2160_nv12);
191 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
192 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
193 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
194 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
195 vEncSample->WaitForEOS();
196 }
197 }
198
199 /**
200 * @tc.number : VIDEO_ENCODE_MULTIFILE_0040
201 * @tc.name : h265 encode config 1920_1080 surface change 1920_1080 1080_1920 1280_1280
202 * @tc.desc : function test
203 */
204 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0040, TestSize.Level1)
205 {
206 if (!access("/system/lib64/media/", 0)) {
207 auto vEncSample = make_unique<VEncAPI11Sample>();
208 vEncSample->DEFAULT_WIDTH = 1920;
209 vEncSample->DEFAULT_HEIGHT = 1080;
210 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0040.h265";
211 vEncSample->SURF_INPUT = true;
212 vEncSample->readMultiFiles = true;
213 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
214 vEncSample->fileInfos.push_back(file_1080_1920_nv12);
215 vEncSample->fileInfos.push_back(file_1280_1280_nv12);
216 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_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 }
222 }
223
224 /**
225 * @tc.number : VIDEO_ENCODE_MULTIFILE_0050
226 * @tc.name : h264 encode config 320_240 surface change 640_480 1280_720 1920_1080
227 * @tc.desc : function test
228 */
229 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0050, TestSize.Level1)
230 {
231 if (!access("/system/lib64/media/", 0)) {
232 auto vEncSample = make_unique<VEncAPI11Sample>();
233 vEncSample->DEFAULT_WIDTH = 320;
234 vEncSample->DEFAULT_HEIGHT = 240;
235 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0050.h264";
236 vEncSample->SURF_INPUT = true;
237 vEncSample->readMultiFiles = true;
238 vEncSample->fileInfos.push_back(file_640_480_rgba);
239 vEncSample->fileInfos.push_back(file_1280_720_nv12);
240 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
241 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
242 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
243 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
244 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
245 vEncSample->WaitForEOS();
246 }
247 }
248
249 /**
250 * @tc.number : VIDEO_ENCODE_MULTIFILE_0060
251 * @tc.name : h264 encode config 1280_720 surface change 640_480 1280_720 1920_1080
252 * @tc.desc : function test
253 */
254 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0060, TestSize.Level1)
255 {
256 if (!access("/system/lib64/media/", 0)) {
257 auto vEncSample = make_unique<VEncAPI11Sample>();
258 vEncSample->DEFAULT_WIDTH = 1280;
259 vEncSample->DEFAULT_HEIGHT = 720;
260 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0060.h264";
261 vEncSample->SURF_INPUT = true;
262 vEncSample->readMultiFiles = true;
263 vEncSample->fileInfos.push_back(file_640_480_rgba);
264 vEncSample->fileInfos.push_back(file_1280_720_nv12);
265 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
266 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
267 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
268 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
269 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
270 vEncSample->WaitForEOS();
271 }
272 }
273
274 /**
275 * @tc.number : VIDEO_ENCODE_MULTIFILE_0070
276 * @tc.name : h264 encode config 3840_2160 surface change 640_480 1280_536 1280_720 1920_816 1920_1080 3840_2160
277 * @tc.desc : function test
278 */
279 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0070, TestSize.Level0)
280 {
281 if (!access("/system/lib64/media/", 0)) {
282 auto vEncSample = make_unique<VEncAPI11Sample>();
283 vEncSample->DEFAULT_WIDTH = 3840;
284 vEncSample->DEFAULT_HEIGHT = 2160;
285 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0070.h264";
286 vEncSample->SURF_INPUT = true;
287 vEncSample->readMultiFiles = true;
288 vEncSample->fileInfos.push_back(file_640_480_rgba);
289 vEncSample->fileInfos.push_back(file_1280_536_nv21);
290 vEncSample->fileInfos.push_back(file_1280_720_nv12);
291 vEncSample->fileInfos.push_back(file_1920_816_rgba);
292 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
293 vEncSample->fileInfos.push_back(file_3840_2160_nv12);
294 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
295 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
296 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
297 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
298 vEncSample->WaitForEOS();
299 }
300 }
301
302 /**
303 * @tc.number : VIDEO_ENCODE_MULTIFILE_0080
304 * @tc.name : h264 encode config 1920_1080 surface change 1920_1080 1080_1920 1280_1280
305 * @tc.desc : function test
306 */
307 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0080, TestSize.Level1)
308 {
309 if (!access("/system/lib64/media/", 0)) {
310 auto vEncSample = make_unique<VEncAPI11Sample>();
311 vEncSample->DEFAULT_WIDTH = 1920;
312 vEncSample->DEFAULT_HEIGHT = 1080;
313 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0080.h264";
314 vEncSample->SURF_INPUT = true;
315 vEncSample->readMultiFiles = true;
316 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
317 vEncSample->fileInfos.push_back(file_1080_1920_nv12);
318 vEncSample->fileInfos.push_back(file_1280_1280_nv12);
319 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
320 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
321 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
322 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
323 vEncSample->WaitForEOS();
324 }
325 }
326
327 /**
328 * @tc.number : VIDEO_ENCODE_MULTIFILE_0090
329 * @tc.name : config main10 set format 8bit surface send 8bit yuv
330 * @tc.desc : function test
331 */
332 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0090, TestSize.Level1)
333 {
334 if (!access("/system/lib64/media/", 0)) {
335 auto vEncSample = make_unique<VEncAPI11Sample>();
336 vEncSample->DEFAULT_WIDTH = 3840;
337 vEncSample->DEFAULT_HEIGHT = 2160;
338 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0090.h265";
339 vEncSample->SURF_INPUT = true;
340 vEncSample->readMultiFiles = true;
341 vEncSample->configMain10 = true;
342 vEncSample->setFormat8Bit = true;
343 vEncSample->fileInfos.push_back(file_1280_720_nv12);
344 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
345 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
346 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
347 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
348 vEncSample->WaitForEOS();
349 }
350 }
351
352 /**
353 * @tc.number : VIDEO_ENCODE_MULTIFILE_0100
354 * @tc.name : config main set format 10bit surface send 10bit yuv
355 * @tc.desc : function test
356 */
357 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0100, TestSize.Level1)
358 {
359 if (!access("/system/lib64/media/", 0)) {
360 auto vEncSample = make_unique<VEncAPI11Sample>();
361 vEncSample->DEFAULT_WIDTH = 3840;
362 vEncSample->DEFAULT_HEIGHT = 2160;
363 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0100.h265";
364 vEncSample->SURF_INPUT = true;
365 vEncSample->readMultiFiles = true;
366 vEncSample->configMain = true;
367 vEncSample->setFormat10Bit = true;
368 vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
369 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
370 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
371 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
372 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
373 vEncSample->WaitForEOS();
374 }
375 }
376
377 /**
378 * @tc.number : VIDEO_ENCODE_MULTIFILE_0110
379 * @tc.name : Not supported pixelFormat rgbx
380 * @tc.desc : function test
381 */
382 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0110, TestSize.Level1)
383 {
384 if (!access("/system/lib64/media/", 0)) {
385 auto vEncSample = make_unique<VEncAPI11Sample>();
386 vEncSample->DEFAULT_WIDTH = 3840;
387 vEncSample->DEFAULT_HEIGHT = 2160;
388 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0110.h265";
389 vEncSample->SURF_INPUT = true;
390 vEncSample->readMultiFiles = true;
391 vEncSample->setFormatRbgx = true;
392 vEncSample->fileInfos.push_back(file_640_480_rgba);
393 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
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 }
399 }
400
401 /**
402 * @tc.number : VIDEO_ENCODE_MULTIFILE_0120
403 * @tc.name : config main set format 8bit send 10bit yuv
404 * @tc.desc : function test
405 */
406 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0120, TestSize.Level1)
407 {
408 if (!access("/system/lib64/media/", 0)) {
409 auto vEncSample = make_unique<VEncAPI11Sample>();
410 vEncSample->DEFAULT_WIDTH = 3840;
411 vEncSample->DEFAULT_HEIGHT = 2160;
412 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0120.h265";
413 vEncSample->SURF_INPUT = true;
414 vEncSample->readMultiFiles = true;
415 vEncSample->configMain = true;
416 vEncSample->setFormat8Bit = true;
417 vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
418 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
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 }
424 }
425
426 /**
427 * @tc.number : VIDEO_ENCODE_MULTIFILE_0130
428 * @tc.name : config main10 set format 10bit send 8bit yuv
429 * @tc.desc : function test
430 */
431 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0130, TestSize.Level1)
432 {
433 if (!access("/system/lib64/media/", 0)) {
434 auto vEncSample = make_unique<VEncAPI11Sample>();
435 vEncSample->DEFAULT_WIDTH = 3840;
436 vEncSample->DEFAULT_HEIGHT = 2160;
437 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0130.h265";
438 vEncSample->SURF_INPUT = true;
439 vEncSample->readMultiFiles = true;
440 vEncSample->configMain10 = true;
441 vEncSample->setFormat10Bit = true;
442 vEncSample->fileInfos.push_back(file_1280_720_nv12);
443 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
444 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
445 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
446 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
447 vEncSample->WaitForEOS();
448 }
449 }
450
451 /**
452 * @tc.number : VIDEO_ENCODE_MULTIFILE_0140
453 * @tc.name : config main10 set format 8bit send 10bit yuv
454 * @tc.desc : function test
455 */
456 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0140, TestSize.Level1)
457 {
458 if (!access("/system/lib64/media/", 0)) {
459 auto vEncSample = make_unique<VEncAPI11Sample>();
460 vEncSample->DEFAULT_WIDTH = 3840;
461 vEncSample->DEFAULT_HEIGHT = 2160;
462 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0140.h265";
463 vEncSample->SURF_INPUT = true;
464 vEncSample->readMultiFiles = true;
465 vEncSample->configMain10 = true;
466 vEncSample->setFormat8Bit = true;
467 vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
468 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
469 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
470 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
471 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
472 vEncSample->WaitForEOS();
473 }
474 }
475
476 /**
477 * @tc.number : VIDEO_ENCODE_MULTIFILE_0150
478 * @tc.name : config main10 set format 10bit send 8bit yuv
479 * @tc.desc : function test
480 */
481 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0150, TestSize.Level1)
482 {
483 if (!access("/system/lib64/media/", 0)) {
484 auto vEncSample = make_unique<VEncAPI11Sample>();
485 vEncSample->DEFAULT_WIDTH = 3840;
486 vEncSample->DEFAULT_HEIGHT = 2160;
487 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0150.h265";
488 vEncSample->SURF_INPUT = true;
489 vEncSample->readMultiFiles = true;
490 vEncSample->configMain10 = true;
491 vEncSample->setFormat10Bit = true;
492 vEncSample->fileInfos.push_back(file_1280_720_nv12);
493 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
494 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
495 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
496 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
497 vEncSample->WaitForEOS();
498 }
499 }
500
501 /**
502 * @tc.number : VIDEO_ENCODE_REPEAT_0100
503 * @tc.name : set frame after 0
504 * @tc.desc : api test
505 */
506 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_0100, TestSize.Level0)
507 {
508 if (cap != nullptr) {
509 auto vEncSample = make_unique<VEncAPI11Sample>();
510 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
511 vEncSample->DEFAULT_WIDTH = 1280;
512 vEncSample->DEFAULT_HEIGHT = 720;
513 vEncSample->DEFAULT_BITRATE_MODE = CBR;
514 vEncSample->SURF_INPUT = true;
515 vEncSample->enableRepeat = true;
516 vEncSample->setMaxCount = true;
517 vEncSample->DEFAULT_FRAME_AFTER = 0;
518 vEncSample->DEFAULT_MAX_COUNT = -1;
519 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
520 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
521 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
522 }
523 }
524
525 /**
526 * @tc.number : VIDEO_ENCODE_REPEAT_0200
527 * @tc.name : set frame after -1
528 * @tc.desc : api test
529 */
530 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_0200, TestSize.Level1)
531 {
532 if (cap != nullptr) {
533 auto vEncSample = make_unique<VEncAPI11Sample>();
534 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
535 vEncSample->DEFAULT_WIDTH = 1280;
536 vEncSample->DEFAULT_HEIGHT = 720;
537 vEncSample->DEFAULT_BITRATE_MODE = CBR;
538 vEncSample->SURF_INPUT = true;
539 vEncSample->enableRepeat = true;
540 vEncSample->setMaxCount = true;
541 vEncSample->DEFAULT_FRAME_AFTER = -1;
542 vEncSample->DEFAULT_MAX_COUNT = -1;
543 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
544 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
545 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
546 }
547 }
548
549 /**
550 * @tc.number : VIDEO_ENCODE_REPEAT_0300
551 * @tc.name : set max count 0
552 * @tc.desc : api test
553 */
554 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_0300, TestSize.Level1)
555 {
556 if (cap != nullptr) {
557 auto vEncSample = make_unique<VEncAPI11Sample>();
558 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
559 vEncSample->DEFAULT_WIDTH = 1280;
560 vEncSample->DEFAULT_HEIGHT = 720;
561 vEncSample->DEFAULT_BITRATE_MODE = CBR;
562 vEncSample->SURF_INPUT = true;
563 vEncSample->enableRepeat = true;
564 vEncSample->setMaxCount = true;
565 vEncSample->DEFAULT_FRAME_AFTER = 1;
566 vEncSample->DEFAULT_MAX_COUNT = 0;
567 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
568 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
569 ASSERT_EQ(AV_ERR_INVALID_VAL, vEncSample->ConfigureVideoEncoder());
570 }
571 }
572
573 /**
574 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0100
575 * @tc.name : repeat surface h264 encode send eos,max count -1,frame after 73ms
576 * @tc.desc : function test
577 */
578 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0100, TestSize.Level0)
579 {
580 if (cap != nullptr) {
581 auto vEncSample = make_unique<VEncAPI11Sample>();
582 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
583 vEncSample->DEFAULT_WIDTH = 1280;
584 vEncSample->DEFAULT_HEIGHT = 720;
585 vEncSample->DEFAULT_BITRATE_MODE = CBR;
586 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0100.h264";
587 vEncSample->SURF_INPUT = true;
588 vEncSample->enableRepeat = true;
589 vEncSample->enableSeekEos = true;
590 vEncSample->setMaxCount = true;
591 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
592 vEncSample->DEFAULT_MAX_COUNT = -1;
593 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
594 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
595 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
596 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
597 vEncSample->WaitForEOS();
598 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
599 cout << "outCount: " << vEncSample->outCount << endl;
600 EXPECT_LE(vEncSample->outCount, COUNT_TWENTY_SEVEN);
601 EXPECT_GE(vEncSample->outCount, COUNT_TWENTY_THREE);
602 }
603 }
604
605 /**
606 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0200
607 * @tc.name : repeat surface h264 encode send eos,max count 2,frame after 73ms
608 * @tc.desc : function test
609 */
610 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0200, TestSize.Level0)
611 {
612 if (cap != nullptr) {
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_0200.h264";
619 vEncSample->SURF_INPUT = true;
620 vEncSample->enableSeekEos = true;
621 vEncSample->enableRepeat = true;
622 vEncSample->setMaxCount = true;
623 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
624 vEncSample->DEFAULT_MAX_COUNT = MAX_COUNT;
625 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
626 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
627 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
628 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
629 vEncSample->WaitForEOS();
630 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
631 cout << "outCount: " << vEncSample->outCount << endl;
632 ASSERT_EQ(COUNT_SEVENTEEN, vEncSample->outCount);
633 }
634 }
635
636 /**
637 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0300
638 * @tc.name : repeat surface h264 encode send frame,max count -1,frame after 73ms
639 * @tc.desc : function test
640 */
641 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0300, TestSize.Level0)
642 {
643 if (cap != nullptr) {
644 auto vEncSample = make_unique<VEncAPI11Sample>();
645 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
646 vEncSample->DEFAULT_WIDTH = 1280;
647 vEncSample->DEFAULT_HEIGHT = 720;
648 vEncSample->DEFAULT_BITRATE_MODE = CBR;
649 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0300.h264";
650 vEncSample->SURF_INPUT = true;
651 vEncSample->enableRepeat = true;
652 vEncSample->setMaxCount = true;
653 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
654 vEncSample->DEFAULT_MAX_COUNT = -1;
655 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
656 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
657 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
658 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
659 vEncSample->WaitForEOS();
660 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
661 cout << "outCount: " << vEncSample->outCount << endl;
662 EXPECT_LE(vEncSample->outCount, COUNT_THIRTY_SEVEN);
663 EXPECT_GE(vEncSample->outCount, COUNT_THIRTY_THREE);
664 }
665 }
666
667 /**
668 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0400
669 * @tc.name : repeat surface h264 encode send frame,max count 1,frame after 73ms
670 * @tc.desc : function test
671 */
672 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0400, TestSize.Level0)
673 {
674 if (cap != nullptr) {
675 auto vEncSample = make_unique<VEncAPI11Sample>();
676 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
677 vEncSample->DEFAULT_WIDTH = 1280;
678 vEncSample->DEFAULT_HEIGHT = 720;
679 vEncSample->DEFAULT_BITRATE_MODE = CBR;
680 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0400.h264";
681 vEncSample->SURF_INPUT = true;
682 vEncSample->enableRepeat = true;
683 vEncSample->setMaxCount = true;
684 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
685 vEncSample->DEFAULT_MAX_COUNT = 1;
686 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
687 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
688 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
689 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
690 vEncSample->WaitForEOS();
691 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
692 cout << "outCount: " << vEncSample->outCount << endl;
693 ASSERT_EQ(COUNT_TWENTY_SIX, vEncSample->outCount);
694 }
695 }
696
697 /**
698 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0500
699 * @tc.name : repeat surface h265 encode send eos,max count -1,frame after 73ms
700 * @tc.desc : function test
701 */
702 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0500, TestSize.Level0)
703 {
704 if (cap != nullptr) {
705 auto vEncSample = make_unique<VEncAPI11Sample>();
706 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
707 vEncSample->DEFAULT_WIDTH = 1280;
708 vEncSample->DEFAULT_HEIGHT = 720;
709 vEncSample->DEFAULT_BITRATE_MODE = CBR;
710 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0500.h264";
711 vEncSample->SURF_INPUT = true;
712 vEncSample->enableRepeat = true;
713 vEncSample->enableSeekEos = true;
714 vEncSample->setMaxCount = true;
715 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
716 vEncSample->DEFAULT_MAX_COUNT = -1;
717 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
718 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
719 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
720 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
721 vEncSample->WaitForEOS();
722 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
723 cout << "outCount: " << vEncSample->outCount << endl;
724 EXPECT_LE(vEncSample->outCount, COUNT_TWENTY_SEVEN);
725 EXPECT_GE(vEncSample->outCount, COUNT_TWENTY_THREE);
726 }
727 }
728
729 /**
730 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0600
731 * @tc.name : repeat surface h265 encode send eos,max count 2,frame after 73ms
732 * @tc.desc : function test
733 */
734 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0600, TestSize.Level0)
735 {
736 if (cap != nullptr) {
737 auto vEncSample = make_unique<VEncAPI11Sample>();
738 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
739 vEncSample->DEFAULT_WIDTH = 1280;
740 vEncSample->DEFAULT_HEIGHT = 720;
741 vEncSample->DEFAULT_BITRATE_MODE = CBR;
742 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0600.h264";
743 vEncSample->SURF_INPUT = true;
744 vEncSample->enableSeekEos = true;
745 vEncSample->enableRepeat = true;
746 vEncSample->setMaxCount = true;
747 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
748 vEncSample->DEFAULT_MAX_COUNT = MAX_COUNT;
749 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
750 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
751 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
752 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
753 vEncSample->WaitForEOS();
754 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
755 cout << "outCount: " << vEncSample->outCount << endl;
756 ASSERT_EQ(COUNT_SEVENTEEN, vEncSample->outCount);
757 }
758 }
759
760 /**
761 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0700
762 * @tc.name : repeat surface h265 encode send frame,max count -1,frame after 73ms
763 * @tc.desc : function test
764 */
765 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0700, TestSize.Level0)
766 {
767 if (cap != nullptr) {
768 auto vEncSample = make_unique<VEncAPI11Sample>();
769 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
770 vEncSample->DEFAULT_WIDTH = 1280;
771 vEncSample->DEFAULT_HEIGHT = 720;
772 vEncSample->DEFAULT_BITRATE_MODE = CBR;
773 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0700.h264";
774 vEncSample->SURF_INPUT = true;
775 vEncSample->enableRepeat = true;
776 vEncSample->setMaxCount = true;
777 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
778 vEncSample->DEFAULT_MAX_COUNT = -1;
779 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
780 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
781 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
782 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
783 vEncSample->WaitForEOS();
784 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
785 cout << "outCount: " << vEncSample->outCount << endl;
786 EXPECT_LE(vEncSample->outCount, COUNT_THIRTY_SEVEN);
787 EXPECT_GE(vEncSample->outCount, COUNT_THIRTY_THREE);
788 }
789 }
790
791 /**
792 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0800
793 * @tc.name : repeat surface h265 encode send frame,max count 1,frame after 73ms
794 * @tc.desc : function test
795 */
796 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0800, TestSize.Level0)
797 {
798 if (cap != nullptr) {
799 auto vEncSample = make_unique<VEncAPI11Sample>();
800 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
801 vEncSample->DEFAULT_WIDTH = 1280;
802 vEncSample->DEFAULT_HEIGHT = 720;
803 vEncSample->DEFAULT_BITRATE_MODE = CBR;
804 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0800.h264";
805 vEncSample->SURF_INPUT = true;
806 vEncSample->enableRepeat = true;
807 vEncSample->setMaxCount = true;
808 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
809 vEncSample->DEFAULT_MAX_COUNT = 1;
810 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
811 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
812 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
813 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
814 vEncSample->WaitForEOS();
815 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
816 cout << "outCount: " << vEncSample->outCount << endl;
817 ASSERT_EQ(COUNT_TWENTY_SIX, vEncSample->outCount);
818 }
819 }
820
821 /**
822 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_0900
823 * @tc.name : repeat surface h265 encode send frame,frame after 73ms
824 * @tc.desc : function test
825 */
826 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_0900, TestSize.Level0)
827 {
828 if (cap != nullptr) {
829 auto vEncSample = make_unique<VEncAPI11Sample>();
830 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
831 vEncSample->DEFAULT_WIDTH = 1280;
832 vEncSample->DEFAULT_HEIGHT = 720;
833 vEncSample->DEFAULT_BITRATE_MODE = CBR;
834 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_0900.h264";
835 vEncSample->SURF_INPUT = true;
836 vEncSample->enableRepeat = true;
837 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
838 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
839 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
840 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
841 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
842 vEncSample->WaitForEOS();
843 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
844 cout << "outCount: " << vEncSample->outCount << endl;
845 ASSERT_EQ(COUNT_THIRTY_FIVE, vEncSample->outCount);
846 }
847 }
848
849 /**
850 * @tc.number : VIDEO_ENCODE_REPEAT_FUNC_1000
851 * @tc.name : repeat surface h264 encode send frame,frame after 73ms
852 * @tc.desc : function test
853 */
854 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_REPEAT_FUNC_1000, TestSize.Level0)
855 {
856 if (cap != nullptr) {
857 auto vEncSample = make_unique<VEncAPI11Sample>();
858 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
859 vEncSample->DEFAULT_WIDTH = 1280;
860 vEncSample->DEFAULT_HEIGHT = 720;
861 vEncSample->DEFAULT_BITRATE_MODE = CBR;
862 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_INNER_REPEAT_FUNC_1000.h264";
863 vEncSample->SURF_INPUT = true;
864 vEncSample->enableRepeat = true;
865 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
866 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
867 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
868 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
869 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
870 vEncSample->WaitForEOS();
871 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
872 cout << "outCount: " << vEncSample->outCount << endl;
873 ASSERT_EQ(COUNT_THIRTY_FIVE, vEncSample->outCount);
874 }
875 }
876
877 /**
878 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0010
879 * @tc.name : setcallback-config
880 * @tc.desc : function test
881 */
882 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0010, TestSize.Level2)
883 {
884 if (cap != nullptr) {
885 auto vEncSample = make_unique<VEncAPI11Sample>();
886 vEncSample->enbleSyncMode = 1;
887 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
888 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
889 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vEncSample->ConfigureVideoEncoder());
890 }
891 }
892
893 /**
894 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0020
895 * @tc.name : setcallback-start-queryInputBuffer
896 * @tc.desc : function test
897 */
898 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0020, TestSize.Level2)
899 {
900 if (cap != nullptr) {
901 auto vEncSample = make_unique<VEncAPI11Sample>();
902 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
903 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
904 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
905 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
906 uint32_t index = 0;
907 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vEncSample->QueryInputBuffer(index, 0));
908 }
909 }
910
911 /**
912 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0030
913 * @tc.name : setcallback-start-QueryOutputBuffer
914 * @tc.desc : function test
915 */
916 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0030, TestSize.Level2)
917 {
918 if (cap != nullptr) {
919 auto vEncSample = make_unique<VEncAPI11Sample>();
920 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
921 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
922 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
923 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
924 uint32_t index = 0;
925 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vEncSample->QueryOutputBuffer(index, 0));
926 }
927 }
928
929 /**
930 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0040
931 * @tc.name : config sync -setcallback
932 * @tc.desc : function test
933 */
934 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0040, TestSize.Level2)
935 {
936 if (cap != nullptr) {
937 auto vEncSample = make_unique<VEncAPI11Sample>();
938 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
939 vEncSample->enbleSyncMode = 1;
940 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
941 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vEncSample->SetVideoEncoderCallback());
942 }
943 }
944
945 /**
946 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0050
947 * @tc.name : config sync -setcallback
948 * @tc.desc : function test
949 */
950 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0050, TestSize.Level2)
951 {
952 if (cap != nullptr) {
953 auto vEncSample = make_unique<VEncAPI11Sample>();
954 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
955 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
956 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
957 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
958 ASSERT_EQ(AV_ERR_OK, vEncSample->Reset());
959 vEncSample->enbleSyncMode = 1;
960 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
961 }
962 }
963
964 /**
965 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0060
966 * @tc.name : config sync -setcallback
967 * @tc.desc : function test
968 */
969 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0060, TestSize.Level2)
970 {
971 if (cap != nullptr) {
972 auto vEncSample = make_unique<VEncAPI11Sample>();
973 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
974 vEncSample->enbleSyncMode = 1;
975 vEncSample->SURF_INPUT = true;
976 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
977 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateSurface());
978 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
979 uint32_t index = 0;
980 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vEncSample->QueryInputBuffer(index, 0));
981 }
982 }
983
984 /**
985 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0070
986 * @tc.name : flush-queryInputBuffer
987 * @tc.desc : function test
988 */
989 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0070, TestSize.Level2)
990 {
991 if (cap != nullptr) {
992 auto vEncSample = make_unique<VEncAPI11Sample>();
993 vEncSample->enbleSyncMode = 1;
994 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
995 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
996 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
997 ASSERT_EQ(AV_ERR_OK, vEncSample->Flush());
998 uint32_t index = 0;
999 ASSERT_EQ(AV_ERR_INVALID_STATE, vEncSample->QueryInputBuffer(index, 0));
1000 }
1001 }
1002
1003 /**
1004 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0080
1005 * @tc.name : flush-queryOutputBuffer
1006 * @tc.desc : function test
1007 */
1008 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0080, TestSize.Level2)
1009 {
1010 if (cap != nullptr) {
1011 auto vEncSample = make_unique<VEncAPI11Sample>();
1012 vEncSample->enbleSyncMode = 1;
1013 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1014 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1015 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
1016 ASSERT_EQ(AV_ERR_OK, vEncSample->Flush());
1017 uint32_t index = 0;
1018 ASSERT_EQ(AV_ERR_INVALID_STATE, vEncSample->QueryOutputBuffer(index, 0));
1019 }
1020 }
1021
1022 /**
1023 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0090
1024 * @tc.name : GetInputBuffer repeated index
1025 * @tc.desc : function test
1026 */
1027 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0090, TestSize.Level2)
1028 {
1029 if (cap != nullptr) {
1030 auto vEncSample = make_unique<VEncAPI11Sample>();
1031 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1032 vEncSample->enbleSyncMode = 1;
1033 vEncSample->getInputBufferIndexRepeat = true;
1034 vEncSample->isRunning_.store(true);
1035 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1036 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1037 ASSERT_EQ(AV_ERR_OK, vEncSample->OpenFile());
1038 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
1039 vEncSample->SyncInputFunc();
1040 ASSERT_EQ(true, vEncSample->abnormalIndexValue);
1041 }
1042 }
1043
1044 /**
1045 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0100
1046 * @tc.name : GetInputBuffer nonexistent index
1047 * @tc.desc : function test
1048 */
1049 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0100, TestSize.Level2)
1050 {
1051 if (cap != nullptr) {
1052 auto vEncSample = make_unique<VEncAPI11Sample>();
1053 vEncSample->enbleSyncMode = 1;
1054 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1055 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1056 ASSERT_EQ(AV_ERR_OK, vEncSample->Start());
1057 uint32_t index = 0;
1058 ASSERT_EQ(AV_ERR_OK, vEncSample->QueryInputBuffer(index, -1));
1059 ASSERT_EQ(nullptr, vEncSample->GetInputBuffer(index+100));
1060 }
1061 }
1062
1063 /**
1064 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0110
1065 * @tc.name : GetOutputBuffer repeated index
1066 * @tc.desc : function test
1067 */
1068 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0110, TestSize.Level2)
1069 {
1070 if (cap != nullptr) {
1071 auto vEncSample = make_unique<VEncAPI11Sample>();
1072 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1073 vEncSample->enbleSyncMode = 1;
1074 vEncSample->getOutputBufferIndexRepeated = true;
1075 vEncSample->noDestroy = true;
1076 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1077 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1078 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1079 vEncSample->WaitForEOS();
1080 ASSERT_EQ(true, vEncSample->abnormalIndexValue);
1081 }
1082 }
1083
1084 /**
1085 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0120
1086 * @tc.name : GetOutputBuffer nonexistent index
1087 * @tc.desc : function test
1088 */
1089 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0120, TestSize.Level2)
1090 {
1091 if (cap != nullptr) {
1092 auto vEncSample = make_unique<VEncAPI11Sample>();
1093 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1094 vEncSample->enbleSyncMode = 1;
1095 vEncSample->getOutputBufferIndexNoExisted = true;
1096 vEncSample->noDestroy = true;
1097 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1098 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1099 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1100 vEncSample->WaitForEOS();
1101 ASSERT_EQ(true, vEncSample->abnormalIndexValue);
1102 }
1103 }
1104
1105 /**
1106 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0130
1107 * @tc.name : 264 buffer cbr sync encode
1108 * @tc.desc : function test
1109 */
1110 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0130, TestSize.Level0)
1111 {
1112 if (cap != nullptr) {
1113 auto vEncSample = make_unique<VEncAPI11Sample>();
1114 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1115 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0130.h264";
1116 vEncSample->enbleSyncMode = 1;
1117 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1118 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1119 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1120 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1121 vEncSample->WaitForEOS();
1122 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1123 }
1124 }
1125
1126 /**
1127 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0140
1128 * @tc.name : 264 buffer VBR sync encode
1129 * @tc.desc : function test
1130 */
1131 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0140, TestSize.Level1)
1132 {
1133 if (cap != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_VBR)) {
1134 auto vEncSample = make_unique<VEncAPI11Sample>();
1135 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1136 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0140.h264";
1137 vEncSample->enbleSyncMode = 1;
1138 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1139 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1140 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1141 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1142 vEncSample->WaitForEOS();
1143 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1144 }
1145 }
1146
1147 /**
1148 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0150
1149 * @tc.name : 264 buffer cq sync encode
1150 * @tc.desc : function test
1151 */
1152 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0150, TestSize.Level1)
1153 {
1154 if (cap != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_CQ)) {
1155 auto vEncSample = make_unique<VEncAPI11Sample>();
1156 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1157 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0150.h264";
1158 vEncSample->enbleSyncMode = 1;
1159 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1160 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1161 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1162 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1163 vEncSample->WaitForEOS();
1164 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1165 }
1166 }
1167
1168 /**
1169 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0160
1170 * @tc.name : 264 buffer SQR sync encode
1171 * @tc.desc : function test
1172 */
1173 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0160, TestSize.Level1)
1174 {
1175 if (cap != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_SQR)) {
1176 auto vEncSample = make_unique<VEncAPI11Sample>();
1177 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1178 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0160.h264";
1179 vEncSample->enbleSyncMode = 1;
1180 vEncSample->DEFAULT_BITRATE_MODE = SQR;
1181 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1182 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1183 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1184 vEncSample->WaitForEOS();
1185 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1186 }
1187 }
1188
1189 /**
1190 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0170
1191 * @tc.name : 264 surface cbr sync encode
1192 * @tc.desc : function test
1193 */
1194 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0170, TestSize.Level0)
1195 {
1196 if (cap != nullptr) {
1197 auto vEncSample = make_unique<VEncAPI11Sample>();
1198 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1199 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0170.h264";
1200 vEncSample->enbleSyncMode = 1;
1201 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1202 vEncSample->SURF_INPUT = true;
1203 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1204 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1205 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1206 vEncSample->WaitForEOS();
1207 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1208 }
1209 }
1210
1211 /**
1212 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0180
1213 * @tc.name : 264 surface VBR sync encode
1214 * @tc.desc : function test
1215 */
1216 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0180, TestSize.Level1)
1217 {
1218 if (cap != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_VBR)) {
1219 auto vEncSample = make_unique<VEncAPI11Sample>();
1220 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1221 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0180.h264";
1222 vEncSample->enbleSyncMode = 1;
1223 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1224 vEncSample->SURF_INPUT = true;
1225 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1226 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1227 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1228 vEncSample->WaitForEOS();
1229 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1230 }
1231 }
1232
1233 /**
1234 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0190
1235 * @tc.name : 264 surface cq sync encode
1236 * @tc.desc : function test
1237 */
1238 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0190, TestSize.Level1)
1239 {
1240 if (cap != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_CQ)) {
1241 auto vEncSample = make_unique<VEncAPI11Sample>();
1242 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1243 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0190.h264";
1244 vEncSample->enbleSyncMode = 1;
1245 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1246 vEncSample->SURF_INPUT = true;
1247 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1248 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1249 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1250 vEncSample->WaitForEOS();
1251 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1252 }
1253 }
1254
1255 /**
1256 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0200
1257 * @tc.name : 264 surface SQR sync encode
1258 * @tc.desc : function test
1259 */
1260 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0200, TestSize.Level1)
1261 {
1262 if (cap != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap, BITRATE_MODE_SQR)) {
1263 auto vEncSample = make_unique<VEncAPI11Sample>();
1264 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1265 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0200.h264";
1266 vEncSample->enbleSyncMode = 1;
1267 vEncSample->DEFAULT_BITRATE_MODE = SQR;
1268 vEncSample->SURF_INPUT = true;
1269 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1270 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1271 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1272 vEncSample->WaitForEOS();
1273 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1274 }
1275 }
1276
1277 /**
1278 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0210
1279 * @tc.name : 265 buffer cbr sync encode
1280 * @tc.desc : function test
1281 */
1282 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0210, TestSize.Level0)
1283 {
1284 if (cap_hevc != nullptr) {
1285 auto vEncSample = make_unique<VEncAPI11Sample>();
1286 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1287 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0210.h265";
1288 vEncSample->enbleSyncMode = 1;
1289 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1290 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1291 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1292 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1293 vEncSample->WaitForEOS();
1294 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1295 }
1296 }
1297
1298 /**
1299 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0220
1300 * @tc.name : 265 buffer VBR sync encode
1301 * @tc.desc : function test
1302 */
1303 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0220, TestSize.Level1)
1304 {
1305 if (cap_hevc != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap_hevc, BITRATE_MODE_VBR)) {
1306 auto vEncSample = make_unique<VEncAPI11Sample>();
1307 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1308 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0220.h265";
1309 vEncSample->enbleSyncMode = 1;
1310 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1311 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1312 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1313 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1314 vEncSample->WaitForEOS();
1315 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1316 }
1317 }
1318
1319 /**
1320 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0230
1321 * @tc.name : 265 buffer cq sync encode
1322 * @tc.desc : function test
1323 */
1324 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0230, TestSize.Level1)
1325 {
1326 if (cap_hevc != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap_hevc, BITRATE_MODE_CQ)) {
1327 auto vEncSample = make_unique<VEncAPI11Sample>();
1328 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1329 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0230.h265";
1330 vEncSample->enbleSyncMode = 1;
1331 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1332 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1333 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1334 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1335 vEncSample->WaitForEOS();
1336 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1337 }
1338 }
1339
1340 /**
1341 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0240
1342 * @tc.name : 265 buffer SQR sync encode
1343 * @tc.desc : function test
1344 */
1345 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0240, TestSize.Level1)
1346 {
1347 if (cap_hevc != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap_hevc, BITRATE_MODE_SQR)) {
1348 auto vEncSample = make_unique<VEncAPI11Sample>();
1349 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1350 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0240.h265";
1351 vEncSample->enbleSyncMode = 1;
1352 vEncSample->DEFAULT_BITRATE_MODE = SQR;
1353 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1354 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1355 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1356 vEncSample->WaitForEOS();
1357 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1358 }
1359 }
1360
1361 /**
1362 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0250
1363 * @tc.name : 265 surface cbr sync encode
1364 * @tc.desc : function test
1365 */
1366 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0250, TestSize.Level0)
1367 {
1368 if (cap_hevc != nullptr) {
1369 auto vEncSample = make_unique<VEncAPI11Sample>();
1370 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1371 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0250.h265";
1372 vEncSample->enbleSyncMode = 1;
1373 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1374 vEncSample->SURF_INPUT = true;
1375 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1376 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1377 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1378 vEncSample->WaitForEOS();
1379 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1380 }
1381 }
1382
1383 /**
1384 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0260
1385 * @tc.name : 265 surface VBR sync encode
1386 * @tc.desc : function test
1387 */
1388 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0260, TestSize.Level1)
1389 {
1390 if (cap_hevc != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap_hevc, BITRATE_MODE_VBR)) {
1391 auto vEncSample = make_unique<VEncAPI11Sample>();
1392 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1393 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0260.h265";
1394 vEncSample->enbleSyncMode = 1;
1395 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1396 vEncSample->SURF_INPUT = true;
1397 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1398 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1399 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1400 vEncSample->WaitForEOS();
1401 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1402 }
1403 }
1404
1405 /**
1406 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0270
1407 * @tc.name : 265 surface cq sync encode
1408 * @tc.desc : function test
1409 */
1410 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0270, TestSize.Level1)
1411 {
1412 if (cap_hevc != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap_hevc, BITRATE_MODE_CQ)) {
1413 auto vEncSample = make_unique<VEncAPI11Sample>();
1414 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1415 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0270.h265";
1416 vEncSample->enbleSyncMode = 1;
1417 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1418 vEncSample->SURF_INPUT = true;
1419 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1420 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1421 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1422 vEncSample->WaitForEOS();
1423 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1424 }
1425 }
1426
1427 /**
1428 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0280
1429 * @tc.name : 265 surface SQR sync encode
1430 * @tc.desc : function test
1431 */
1432 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0280, TestSize.Level1)
1433 {
1434 if (cap_hevc != nullptr && OH_AVCapability_IsEncoderBitrateModeSupported(cap_hevc, BITRATE_MODE_SQR)) {
1435 auto vEncSample = make_unique<VEncAPI11Sample>();
1436 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1437 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0280.h265";
1438 vEncSample->enbleSyncMode = 1;
1439 vEncSample->DEFAULT_BITRATE_MODE = SQR;
1440 vEncSample->SURF_INPUT = true;
1441 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1442 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1443 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1444 vEncSample->WaitForEOS();
1445 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1446 }
1447 }
1448
1449 /**
1450 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0290
1451 * @tc.name : 265 surface 10bit vbr sync encode
1452 * @tc.desc : function test
1453 */
1454 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0290, TestSize.Level1)
1455 {
1456 if (!access("/system/lib64/media/", 0)) {
1457 auto vEncSample = make_unique<VEncAPI11Sample>();
1458 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0290.h265";
1459 vEncSample->DEFAULT_WIDTH = 1920;
1460 vEncSample->DEFAULT_HEIGHT = 1088;
1461 vEncSample->SURF_INPUT = true;
1462 vEncSample->readMultiFiles = true;
1463 vEncSample->configMain10 = true;
1464 vEncSample->enbleSyncMode = 1;
1465 vEncSample->setFormat10Bit = true;
1466 vEncSample->fileInfos.push_back(file_1920_1088_nv12_10bit);
1467 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1468 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1469 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1470 vEncSample->WaitForEOS();
1471 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1472 }
1473 }
1474
1475 /**
1476 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0300
1477 * @tc.name : h264 resolution change encode
1478 * @tc.desc : function test
1479 */
1480 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0300, TestSize.Level2)
1481 {
1482 if (!access("/system/lib64/media/", 0)) {
1483 auto vEncSample = make_unique<VEncAPI11Sample>();
1484 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0300.h264";
1485 vEncSample->DEFAULT_WIDTH = 1920;
1486 vEncSample->DEFAULT_HEIGHT = 1080;
1487 vEncSample->SURF_INPUT = true;
1488 vEncSample->readMultiFiles = true;
1489 vEncSample->enbleSyncMode = 1;
1490 vEncSample->noDestroy = true;
1491 vEncSample->fileInfos.push_back(file_640_480_rgba);
1492 vEncSample->fileInfos.push_back(file_1280_720_nv12);
1493 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
1494 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1495 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1496 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1497 vEncSample->WaitForEOS();
1498 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1499 }
1500 }
1501
1502 /**
1503 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0310
1504 * @tc.name : h265 resolution change encode
1505 * @tc.desc : function test
1506 */
1507 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0310, TestSize.Level2)
1508 {
1509 if (!access("/system/lib64/media/", 0)) {
1510 auto vEncSample = make_unique<VEncAPI11Sample>();
1511 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0310.h265";
1512 vEncSample->SURF_INPUT = true;
1513 vEncSample->readMultiFiles = true;
1514 vEncSample->DEFAULT_WIDTH = 1920;
1515 vEncSample->DEFAULT_HEIGHT = 1080;
1516 vEncSample->enbleSyncMode = 1;
1517 vEncSample->noDestroy = true;
1518 vEncSample->fileInfos.push_back(file_640_480_rgba);
1519 vEncSample->fileInfos.push_back(file_1280_720_nv12);
1520 vEncSample->fileInfos.push_back(file_1920_1080_nv21);
1521 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1522 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1523 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1524 vEncSample->WaitForEOS();
1525 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1526 }
1527 }
1528
1529 /**
1530 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0320
1531 * @tc.name : 264 repeat sync encode
1532 * @tc.desc : function test
1533 */
1534 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0320, TestSize.Level2)
1535 {
1536 if (cap != nullptr) {
1537 auto vEncSample = make_unique<VEncAPI11Sample>();
1538 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1539 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0320.h264";
1540 vEncSample->SURF_INPUT = true;
1541 vEncSample->enableSeekEos = true;
1542 vEncSample->enableRepeat = true;
1543 vEncSample->setMaxCount = true;
1544 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
1545 vEncSample->DEFAULT_MAX_COUNT = MAX_COUNT;
1546 vEncSample->enbleSyncMode = 1;
1547 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
1548 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1549 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1550 vEncSample->WaitForEOS();
1551 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1552 cout << "outCount: " << vEncSample->outCount << endl;
1553 ASSERT_EQ(COUNT_SEVENTEEN, vEncSample->outCount);
1554 }
1555 }
1556
1557 /**
1558 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0330
1559 * @tc.name : 265 repeat sync encode
1560 * @tc.desc : function test
1561 */
1562 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0330, TestSize.Level2)
1563 {
1564 if (cap_hevc != nullptr) {
1565 auto vEncSample = make_unique<VEncAPI11Sample>();
1566 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1567 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0330.h265";
1568 vEncSample->SURF_INPUT = true;
1569 vEncSample->enableSeekEos = true;
1570 vEncSample->enableRepeat = true;
1571 vEncSample->setMaxCount = true;
1572 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
1573 vEncSample->DEFAULT_MAX_COUNT = MAX_COUNT;
1574 vEncSample->enbleSyncMode = 1;
1575 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1576 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1577 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1578 vEncSample->WaitForEOS();
1579 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1580 cout << "outCount: " << vEncSample->outCount << endl;
1581 ASSERT_EQ(COUNT_SEVENTEEN, vEncSample->outCount);
1582 }
1583 }
1584
1585 /**
1586 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0360
1587 * @tc.name : sync encode queryInputBuffer timeout 0
1588 * @tc.desc : function test
1589 */
1590 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0360, TestSize.Level0)
1591 {
1592 if (cap_hevc != nullptr) {
1593 auto vEncSample = make_unique<VEncAPI11Sample>();
1594 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1595 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0360.h265";
1596 vEncSample->enbleSyncMode = 1;
1597 vEncSample->syncInputWaitTime = 0;
1598 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1599 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1600 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1601 vEncSample->WaitForEOS();
1602 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1603 }
1604 }
1605
1606 /**
1607 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0370
1608 * @tc.name : sync encode queryInputBuffer timeout 100000
1609 * @tc.desc : function test
1610 */
1611 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0370, TestSize.Level1)
1612 {
1613 if (cap_hevc != nullptr) {
1614 auto vEncSample = make_unique<VEncAPI11Sample>();
1615 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1616 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0370.h265";
1617 vEncSample->enbleSyncMode = 1;
1618 vEncSample->syncInputWaitTime = 100000;
1619 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1620 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1621 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1622 vEncSample->WaitForEOS();
1623 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1624 }
1625 }
1626
1627 /**
1628 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0380
1629 * @tc.name : sync encode syncOutputWaitTime timeout 0
1630 * @tc.desc : function test
1631 */
1632 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0380, TestSize.Level0)
1633 {
1634 if (cap_hevc != nullptr) {
1635 auto vEncSample = make_unique<VEncAPI11Sample>();
1636 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1637 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0380.h265";
1638 vEncSample->enbleSyncMode = 1;
1639 vEncSample->syncOutputWaitTime = 0;
1640 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1641 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1642 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1643 vEncSample->WaitForEOS();
1644 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1645 }
1646 }
1647
1648 /**
1649 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0390
1650 * @tc.name : sync encode syncOutputWaitTime timeout 100000
1651 * @tc.desc : function test
1652 */
1653 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0390, TestSize.Level1)
1654 {
1655 if (cap_hevc != nullptr) {
1656 auto vEncSample = make_unique<VEncAPI11Sample>();
1657 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1658 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0390.h265";
1659 vEncSample->enbleSyncMode = 1;
1660 vEncSample->syncOutputWaitTime = 100000;
1661 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1662 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1663 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1664 vEncSample->WaitForEOS();
1665 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1666 }
1667 }
1668
1669 /**
1670 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0400
1671 * @tc.name : get eos queryInputBuffer
1672 * @tc.desc : function test
1673 */
1674 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0400, TestSize.Level2)
1675 {
1676 if (cap_hevc != nullptr) {
1677 auto vEncSample = make_unique<VEncAPI11Sample>();
1678 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1679 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0400.h265";
1680 vEncSample->enbleSyncMode = 1;
1681 vEncSample->queryInputBufferEOS = true;
1682 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1683 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1684 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1685 vEncSample->WaitForEOS();
1686 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1687 }
1688 }
1689
1690 /**
1691 * @tc.number : VIDEO_ENCODE_SYNC_FUNC_0410
1692 * @tc.name : get eos queryOutputBuffer
1693 * @tc.desc : function test
1694 */
1695 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_SYNC_FUNC_0410, TestSize.Level2)
1696 {
1697 if (cap_hevc != nullptr) {
1698 auto vEncSample = make_unique<VEncAPI11Sample>();
1699 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
1700 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_SYNC_FUNC_0410.h265";
1701 vEncSample->enbleSyncMode = 1;
1702 vEncSample->queryOutputBufferEOS = true;
1703 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1704 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1705 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1706 vEncSample->WaitForEOS();
1707 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1708 }
1709 }
1710
1711 /**
1712 * @tc.number : VIDEO_ENCODE_RGBA1010102_0010
1713 * @tc.name : CBR 176*144 rgba1010102 265 buffer encode
1714 * @tc.desc : function test
1715 */
1716 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0010, TestSize.Level1)
1717 {
1718 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1719 if (!IsSupportRgba1010102Format()) {
1720 return;
1721 }
1722 auto vEncSample = make_unique<VEncAPI11Sample>();
1723 vEncSample->INP_DIR = "/data/test/media/176_144_rgba1010102.yuv";
1724 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0010.h265";
1725 vEncSample->DEFAULT_WIDTH = 176;
1726 vEncSample->DEFAULT_HEIGHT = 144;
1727 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1728 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1729 vEncSample->configMain10 = true;
1730 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1731 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1732 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1733 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1734 vEncSample->WaitForEOS();
1735 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1736 }
1737 }
1738
1739 /**
1740 * @tc.number : VIDEO_ENCODE_RGBA1010102_0020
1741 * @tc.name : CQ 1280*720 rgba1010102 265 buffer encode
1742 * @tc.desc : function test
1743 */
1744 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0020, TestSize.Level0)
1745 {
1746 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1747 if (!IsSupportRgba1010102Format()) {
1748 return;
1749 }
1750 auto vEncSample = make_unique<VEncAPI11Sample>();
1751 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
1752 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0020.h265";
1753 vEncSample->DEFAULT_WIDTH = 1280;
1754 vEncSample->DEFAULT_HEIGHT = 720;
1755 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1756 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1757 vEncSample->configMain10 = true;
1758 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1759 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1760 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1761 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1762 vEncSample->WaitForEOS();
1763 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1764 }
1765 }
1766
1767 /**
1768 * @tc.number : VIDEO_ENCODE_RGBA1010102_0030
1769 * @tc.name : SQR 1920*1080 rgba1010102 265 buffer encode
1770 * @tc.desc : function test
1771 */
1772 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0030, TestSize.Level0)
1773 {
1774 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1775 if (!IsSupportRgba1010102Format()) {
1776 return;
1777 }
1778 auto vEncSample = make_unique<VEncAPI11Sample>();
1779 vEncSample->INP_DIR = "/data/test/media/1920_1080_rgba1010102.yuv";
1780 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0030.h265";
1781 vEncSample->DEFAULT_WIDTH = 1920;
1782 vEncSample->DEFAULT_HEIGHT = 1080;
1783 vEncSample->DEFAULT_BITRATE_MODE = SQR;
1784 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1785 vEncSample->configMain10 = true;
1786 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1787 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1788 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1789 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1790 vEncSample->WaitForEOS();
1791 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1792 }
1793 }
1794
1795 /**
1796 * @tc.number : VIDEO_ENCODE_RGBA1010102_0040
1797 * @tc.name : VBR 4096*4096 rgba1010102 265 buffer encode
1798 * @tc.desc : function test
1799 */
1800 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0040, TestSize.Level1)
1801 {
1802 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1803 if (!IsSupportRgba1010102Format()) {
1804 return;
1805 }
1806 auto vEncSample = make_unique<VEncAPI11Sample>();
1807 vEncSample->INP_DIR = "/data/test/media/4096_4096_rgba1010102.yuv";
1808 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0040.h265";
1809 vEncSample->DEFAULT_WIDTH = 4096;
1810 vEncSample->DEFAULT_HEIGHT = 4096;
1811 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1812 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1813 vEncSample->configMain10 = true;
1814 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1815 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1816 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1817 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1818 vEncSample->WaitForEOS();
1819 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1820 }
1821 }
1822
1823 /**
1824 * @tc.number : VIDEO_ENCODE_RGBA1010102_0050
1825 * @tc.name : CBR 144*144 rgba1010102 265 surface encode
1826 * @tc.desc : function test
1827 */
1828 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0050, TestSize.Level1)
1829 {
1830 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1831 if (!IsSupportRgba1010102Format()) {
1832 return;
1833 }
1834 auto vEncSample = make_unique<VEncAPI11Sample>();
1835 vEncSample->INP_DIR = "/data/test/media/176_144_rgba1010102.yuv";
1836 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0050.h265";
1837 vEncSample->DEFAULT_WIDTH = 176;
1838 vEncSample->DEFAULT_HEIGHT = 144;
1839 vEncSample->DEFAULT_BITRATE_MODE = CBR;
1840 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1841 vEncSample->configMain10 = true;
1842 vEncSample->SURF_INPUT = true;
1843 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1844 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1845 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1846 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1847 vEncSample->WaitForEOS();
1848 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1849 }
1850 }
1851
1852 /**
1853 * @tc.number : VIDEO_ENCODE_RGBA1010102_0060
1854 * @tc.name : CQ 1280*720 rgba1010102 265 surface encode
1855 * @tc.desc : function test
1856 */
1857 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0060, TestSize.Level0)
1858 {
1859 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1860 if (!IsSupportRgba1010102Format()) {
1861 return;
1862 }
1863 auto vEncSample = make_unique<VEncAPI11Sample>();
1864 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
1865 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0060.h265";
1866 vEncSample->DEFAULT_WIDTH = 1280;
1867 vEncSample->DEFAULT_HEIGHT = 720;
1868 vEncSample->DEFAULT_BITRATE_MODE = CQ;
1869 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1870 vEncSample->configMain10 = true;
1871 vEncSample->SURF_INPUT = true;
1872 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1873 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1874 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1875 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1876 vEncSample->WaitForEOS();
1877 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1878 }
1879 }
1880
1881 /**
1882 * @tc.number : VIDEO_ENCODE_RGBA1010102_0070
1883 * @tc.name : SQR 1920*1080 rgba1010102 265 surface encode
1884 * @tc.desc : function test
1885 */
1886 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0070, TestSize.Level0)
1887 {
1888 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1889 if (!IsSupportRgba1010102Format()) {
1890 return;
1891 }
1892 auto vEncSample = make_unique<VEncAPI11Sample>();
1893 vEncSample->INP_DIR = "/data/test/media/1920_1080_rgba1010102.yuv";
1894 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0070.h265";
1895 vEncSample->DEFAULT_WIDTH = 1920;
1896 vEncSample->DEFAULT_HEIGHT = 1080;
1897 vEncSample->DEFAULT_BITRATE_MODE = SQR;
1898 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1899 vEncSample->configMain10 = true;
1900 vEncSample->SURF_INPUT = true;
1901 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1902 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1903 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1904 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1905 vEncSample->WaitForEOS();
1906 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1907 }
1908 }
1909
1910 /**
1911 * @tc.number : VIDEO_ENCODE_RGBA1010102_0080
1912 * @tc.name : VBR 4096*4096 rgba1010102 265 surface encode
1913 * @tc.desc : function test
1914 */
1915 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0080, TestSize.Level1)
1916 {
1917 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1918 if (!IsSupportRgba1010102Format()) {
1919 return;
1920 }
1921 auto vEncSample = make_unique<VEncAPI11Sample>();
1922 vEncSample->INP_DIR = "/data/test/media/4096_4096_rgba1010102.yuv";
1923 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0080.h265";
1924 vEncSample->DEFAULT_WIDTH = 4096;
1925 vEncSample->DEFAULT_HEIGHT = 4096;
1926 vEncSample->DEFAULT_BITRATE_MODE = VBR;
1927 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1928 vEncSample->configMain10 = true;
1929 vEncSample->SURF_INPUT = true;
1930 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1931 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1932 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1933 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1934 vEncSample->WaitForEOS();
1935 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1936 }
1937 }
1938
1939 /**
1940 * @tc.number : VIDEO_ENCODE_RGBA1010102_0090
1941 * @tc.name : repeat rgba1010102 265 surface encode
1942 * @tc.desc : function test
1943 */
1944 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0090, TestSize.Level2)
1945 {
1946 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1947 if (!IsSupportRgba1010102Format()) {
1948 return;
1949 }
1950 auto vEncSample = make_unique<VEncAPI11Sample>();
1951 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
1952 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0090.h265";
1953 vEncSample->DEFAULT_WIDTH = 1280;
1954 vEncSample->DEFAULT_HEIGHT = 720;
1955 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1956 vEncSample->configMain10 = true;
1957 vEncSample->SURF_INPUT = true;
1958 vEncSample->enableRepeat = true;
1959 vEncSample->DEFAULT_FRAME_AFTER = FRAME_AFTER;
1960 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1961 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1962 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
1963 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1964 vEncSample->WaitForEOS();
1965 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1966 }
1967 }
1968
1969 /**
1970 * @tc.number : VIDEO_ENCODE_RGBA1010102_0110
1971 * @tc.name : 分层编码 rgba1010102 265 buffer encode
1972 * @tc.desc : function test
1973 */
1974 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0110, TestSize.Level2)
1975 {
1976 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
1977 if (!IsSupportRgba1010102Format()) {
1978 return;
1979 }
1980 auto vEncSample = make_unique<VEncAPI11Sample>();
1981 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
1982 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0110.h265";
1983 vEncSample->DEFAULT_WIDTH = 1280;
1984 vEncSample->DEFAULT_HEIGHT = 720;
1985 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
1986 vEncSample->configMain10 = true;
1987 vEncSample->TEMPORAL_ENABLE = true;
1988 vEncSample->TEMPORAL_CONFIG = true;
1989 vEncSample->TEMPORAL_JUMP_MODE = true;
1990 int32_t temporalGopSize = 8;
1991 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
1992 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
1993 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
1994 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
1995 vEncSample->WaitForEOS();
1996 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
1997 }
1998 }
1999
2000 /**
2001 * @tc.number : VIDEO_ENCODE_RGBA1010102_0120
2002 * @tc.name : 分层编码 rgba1010102 265 surface encode
2003 * @tc.desc : function test
2004 */
2005 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0120, TestSize.Level2)
2006 {
2007 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2008 if (!IsSupportRgba1010102Format()) {
2009 return;
2010 }
2011 auto vEncSample = make_unique<VEncAPI11Sample>();
2012 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2013 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0120.h265";
2014 vEncSample->DEFAULT_WIDTH = 1280;
2015 vEncSample->DEFAULT_HEIGHT = 720;
2016 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2017 vEncSample->configMain10 = true;
2018 vEncSample->SURF_INPUT = true;
2019 vEncSample->TEMPORAL_ENABLE = true;
2020 vEncSample->TEMPORAL_CONFIG = true;
2021 vEncSample->TEMPORAL_JUMP_MODE = true;
2022 int32_t temporalGopSize = 8;
2023 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2024 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2025 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder_Temporal(temporalGopSize));
2026 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2027 vEncSample->WaitForEOS();
2028 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
2029 }
2030 }
2031
2032 /**
2033 * @tc.number : VIDEO_ENCODE_RGBA1010102_0130
2034 * @tc.name : ltr rgba1010102 265 buffer encode
2035 * @tc.desc : function test
2036 */
2037 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0130, TestSize.Level2)
2038 {
2039 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2040 if (!IsSupportRgba1010102Format()) {
2041 return;
2042 }
2043 auto vEncSample = make_unique<VEncAPI11Sample>();
2044 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2045 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0130.h265";
2046 vEncSample->DEFAULT_WIDTH = 1280;
2047 vEncSample->DEFAULT_HEIGHT = 720;
2048 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2049 vEncSample->configMain10 = true;
2050 vEncSample->enableLTR = true;
2051 vEncSample->ltrParam.ltrCount = 5;
2052 vEncSample->ltrParam.ltrInterval = 5;
2053 vEncSample->ltrParam.enableUseLtr = true;
2054 vEncSample->ltrParam.useLtrIndex = 1;
2055 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2056 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2057 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2058 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2059 vEncSample->WaitForEOS();
2060 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
2061 }
2062 }
2063
2064 /**
2065 * @tc.number : VIDEO_ENCODE_RGBA1010102_0140
2066 * @tc.name : 分层编码 rgba1010102 265 surface encode
2067 * @tc.desc : function test
2068 */
2069 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0140, TestSize.Level2)
2070 {
2071 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2072 if (!IsSupportRgba1010102Format()) {
2073 return;
2074 }
2075 auto vEncSample = make_unique<VEncAPI11Sample>();
2076 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2077 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0140.h265";
2078 vEncSample->DEFAULT_WIDTH = 1280;
2079 vEncSample->DEFAULT_HEIGHT = 720;
2080 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2081 vEncSample->configMain10 = true;
2082 vEncSample->SURF_INPUT = true;
2083 vEncSample->enableLTR = true;
2084 vEncSample->ltrParam.ltrCount = 5;
2085 vEncSample->ltrParam.ltrInterval = 5;
2086 vEncSample->ltrParam.enableUseLtr = true;
2087 vEncSample->ltrParam.useLtrIndex = 1;
2088 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2089 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2090 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2091 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2092 vEncSample->WaitForEOS();
2093 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
2094 }
2095 }
2096
2097 /**
2098 * @tc.number : VIDEO_ENCODE_RGBA1010102_0150
2099 * @tc.name : sync rgba1010102 265 buffer encode
2100 * @tc.desc : function test
2101 */
2102 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0150, TestSize.Level2)
2103 {
2104 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2105 if (!IsSupportRgba1010102Format()) {
2106 return;
2107 }
2108 auto vEncSample = make_unique<VEncAPI11Sample>();
2109 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2110 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0150.h265";
2111 vEncSample->DEFAULT_WIDTH = 1280;
2112 vEncSample->DEFAULT_HEIGHT = 720;
2113 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2114 vEncSample->configMain10 = true;
2115 vEncSample->enbleSyncMode = 1;
2116 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2117 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2118 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2119 vEncSample->WaitForEOS();
2120 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
2121 }
2122 }
2123
2124 /**
2125 * @tc.number : VIDEO_ENCODE_RGBA1010102_0160
2126 * @tc.name : sync rgba1010102 265 surface encode
2127 * @tc.desc : function test
2128 */
2129 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0160, TestSize.Level2)
2130 {
2131 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2132 if (!IsSupportRgba1010102Format()) {
2133 return;
2134 }
2135 auto vEncSample = make_unique<VEncAPI11Sample>();
2136 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2137 vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_RGBA1010102_0160.h265";
2138 vEncSample->DEFAULT_WIDTH = 1280;
2139 vEncSample->DEFAULT_HEIGHT = 720;
2140 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2141 vEncSample->configMain10 = true;
2142 vEncSample->SURF_INPUT = true;
2143 vEncSample->enbleSyncMode = 1;
2144 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2145 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2146 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2147 vEncSample->WaitForEOS();
2148 ASSERT_EQ(AV_ERR_OK, vEncSample->errCount);
2149 }
2150 }
2151
2152 /**
2153 * @tc.number : VIDEO_ENCODE_RGBA1010102_0170
2154 * @tc.name : configure nv12/profile10bit h265 rgba1010102 buffer encode
2155 * @tc.desc : function test
2156 */
2157 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0170, TestSize.Level2)
2158 {
2159 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2160 if (!IsSupportRgba1010102Format()) {
2161 return;
2162 }
2163 auto vEncSample = make_unique<VEncAPI11Sample>();
2164 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2165 vEncSample->DEFAULT_WIDTH = 1280;
2166 vEncSample->DEFAULT_HEIGHT = 720;
2167 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
2168 vEncSample->configMain10 = true;
2169 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2170 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2171 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2172 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2173 vEncSample->WaitForEOS();
2174 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
2175 }
2176 }
2177
2178 /**
2179 * @tc.number : VIDEO_ENCODE_RGBA1010102_0180
2180 * @tc.name : configure rgba/profile10bit h265 rgba1010102 buffer encode
2181 * @tc.desc : function test
2182 */
2183 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0180, TestSize.Level2)
2184 {
2185 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2186 if (!IsSupportRgba1010102Format()) {
2187 return;
2188 }
2189 auto vEncSample = make_unique<VEncAPI11Sample>();
2190 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2191 vEncSample->DEFAULT_WIDTH = 1280;
2192 vEncSample->DEFAULT_HEIGHT = 720;
2193 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA;
2194 vEncSample->configMain10 = true;
2195 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2196 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2197 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2198 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2199 vEncSample->WaitForEOS();
2200 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
2201 }
2202 }
2203
2204 /**
2205 * @tc.number : VIDEO_ENCODE_RGBA1010102_0190
2206 * @tc.name : configure rgba/profile10bit h265 rgba1010102 buffer encode
2207 * @tc.desc : function test
2208 */
2209 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0190, TestSize.Level2)
2210 {
2211 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2212 if (!IsSupportRgba1010102Format()) {
2213 return;
2214 }
2215 auto vEncSample = make_unique<VEncAPI11Sample>();
2216 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2217 vEncSample->DEFAULT_WIDTH = 1280;
2218 vEncSample->DEFAULT_HEIGHT = 720;
2219 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2220 vEncSample->configMain10 = false;
2221 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2222 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2223 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2224 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2225 vEncSample->WaitForEOS();
2226 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
2227 }
2228 }
2229
2230 /**
2231 * @tc.number : VIDEO_ENCODE_RGBA1010102_0200
2232 * @tc.name : configure nv12/profile10bit h265 rgba1010102 surface encode
2233 * @tc.desc : function test
2234 */
2235 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0200, TestSize.Level2)
2236 {
2237 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2238 if (!IsSupportRgba1010102Format()) {
2239 return;
2240 }
2241 auto vEncSample = make_unique<VEncAPI11Sample>();
2242 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2243 vEncSample->DEFAULT_WIDTH = 1280;
2244 vEncSample->DEFAULT_HEIGHT = 720;
2245 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_NV12;
2246 vEncSample->configMain10 = true;
2247 vEncSample->SURF_INPUT = true;
2248 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2249 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2250 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2251 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2252 vEncSample->WaitForEOS();
2253 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
2254 }
2255 }
2256
2257 /**
2258 * @tc.number : VIDEO_ENCODE_RGBA1010102_0210
2259 * @tc.name : configure rgba/profile10bit h265 rgba1010102 surface encode
2260 * @tc.desc : function test
2261 */
2262 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0210, TestSize.Level2)
2263 {
2264 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2265 if (!IsSupportRgba1010102Format()) {
2266 return;
2267 }
2268 auto vEncSample = make_unique<VEncAPI11Sample>();
2269 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2270 vEncSample->DEFAULT_WIDTH = 1280;
2271 vEncSample->DEFAULT_HEIGHT = 720;
2272 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA;
2273 vEncSample->configMain10 = true;
2274 vEncSample->SURF_INPUT = true;
2275 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2276 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2277 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2278 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2279 vEncSample->WaitForEOS();
2280 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
2281 }
2282 }
2283
2284 /**
2285 * @tc.number : VIDEO_ENCODE_RGBA1010102_0220
2286 * @tc.name : configure rgba/profile10bit h265 rgba1010102 surface encode
2287 * @tc.desc : function test
2288 */
2289 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_RGBA1010102_0220, TestSize.Level2)
2290 {
2291 if (cap_hevc != nullptr && ! access("/system/lib64/media/", 0)) {
2292 if (!IsSupportRgba1010102Format()) {
2293 return;
2294 }
2295 auto vEncSample = make_unique<VEncAPI11Sample>();
2296 vEncSample->INP_DIR = "/data/test/media/1280_720_rgba1010102.yuv";
2297 vEncSample->DEFAULT_WIDTH = 1280;
2298 vEncSample->DEFAULT_HEIGHT = 720;
2299 vEncSample->DEFAULT_PIX_FMT = AV_PIXEL_FORMAT_RGBA1010102;
2300 vEncSample->configMain10 = false;
2301 vEncSample->SURF_INPUT = true;
2302 ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
2303 ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
2304 ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
2305 ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
2306 vEncSample->WaitForEOS();
2307 ASSERT_LT(AV_ERR_OK, vEncSample->errCount);
2308 }
2309 }
2310 } // namespace