1 /*
2  * Copyright (C) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <string>
16 #include <limits>
17 #include "meta/format.h"
18 #include "gtest/gtest.h"
19 #include "native_avcodec_videoencoder.h"
20 #include "native_averrors.h"
21 #include "videoenc_api11_sample.h"
22 #include "native_avcodec_base.h"
23 #include "avcodec_codec_name.h"
24 #include "native_avcapability.h"
25 #include "avcodec_info.h"
26 #include "avcodec_list.h"
27 #include "avcodec_common.h"
28 
29 namespace {
30 OH_AVCodec *venc_ = NULL;
31 OH_AVCapability *cap = nullptr;
32 OH_AVCapability *cap_hevc = nullptr;
33 constexpr uint32_t CODEC_NAME_SIZE = 128;
34 char g_codecName[CODEC_NAME_SIZE] = {};
35 char g_codecNameHEVC[CODEC_NAME_SIZE] = {};
36 } // namespace
37 namespace OHOS {
38 namespace Media {
39 class HwEncFunc2NdkTest : public testing::Test {
40 public:
41     static void SetUpTestCase();
42     static void TearDownTestCase();
43     void SetUp() override;
44     void TearDown() override;
45     void InputFunc();
46     void OutputFunc();
47     void Release();
48     int32_t Stop();
49 };
50 } // namespace Media
51 } // namespace OHOS
52 
53 using namespace std;
54 using namespace OHOS;
55 using namespace OHOS::Media;
56 using namespace testing::ext;
57 
58 fileInfo file_640_480_rgba{"/data/test/media/640_480.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 640, 480 };
59 fileInfo file_1280_536_nv21{"/data/test/media/1280_536_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1280, 536 };
60 fileInfo file_1280_720_nv12{"/data/test/media/1280_720_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 720 };
61 fileInfo file_1920_816_rgba{"/data/test/media/1920_816.rgba", NATIVEBUFFER_PIXEL_FMT_RGBA_8888, 1920, 816 };
62 fileInfo file_1920_1080_nv21{"/data/test/media/1920_1080_nv21.yuv", NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP, 1920, 1080 };
63 fileInfo file_3840_2160_nv12{"/data/test/media/3840_2160_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 3840, 2160 };
64 fileInfo file_1280_720_nv12_10bit{"/data/test/media/1280_720_nv12_10bit.yuv",
65     NATIVEBUFFER_PIXEL_FMT_YCBCR_P010, 1280, 720 };
66 fileInfo file_1080_1920_nv12{"/data/test/media/1080_1920_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1080, 1920 };
67 fileInfo file_1280_1280_nv12{"/data/test/media/1280_1280_nv12.yuv", NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP, 1280, 1280 };
68 
SetUpTestCase()69 void HwEncFunc2NdkTest::SetUpTestCase()
70 {
71     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
72     const char *tmpCodecName = OH_AVCapability_GetName(cap);
73     if (memcpy_s(g_codecName, sizeof(g_codecName), tmpCodecName, strlen(tmpCodecName)) != 0)
74         cout << "memcpy failed" << endl;
75     cout << "codecname: " << g_codecName << endl;
76     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
77     const char *tmpCodecNameHevc = OH_AVCapability_GetName(cap_hevc);
78     if (memcpy_s(g_codecNameHEVC, sizeof(g_codecNameHEVC), tmpCodecNameHevc, strlen(tmpCodecNameHevc)) != 0)
79         cout << "memcpy failed" << endl;
80     cout << "codecname_hevc: " << g_codecNameHEVC << endl;
81 }
TearDownTestCase()82 void HwEncFunc2NdkTest::TearDownTestCase() {}
SetUp()83 void HwEncFunc2NdkTest::SetUp() {}
TearDown()84 void HwEncFunc2NdkTest::TearDown()
85 {
86     if (venc_ != NULL) {
87         OH_VideoEncoder_Destroy(venc_);
88         venc_ = nullptr;
89     }
90 }
91 namespace {
92 /**
93  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0010
94  * @tc.name      : h265 encode config 320_240 surface change 640_480 1280_720 1920_1080
95  * @tc.desc      : function test
96  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0010, TestSize.Level1)97 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0010, TestSize.Level1)
98 {
99     if (!access("/system/lib64/media/", 0)) {
100         auto vEncSample = make_unique<VEncAPI11Sample>();
101         vEncSample->DEFAULT_WIDTH = 320;
102         vEncSample->DEFAULT_HEIGHT = 240;
103         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0010.h265";
104         vEncSample->SURF_INPUT = true;
105         vEncSample->readMultiFiles = true;
106         vEncSample->fileInfos.push_back(file_640_480_rgba);
107         vEncSample->fileInfos.push_back(file_1280_720_nv12);
108         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
109         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
110         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
111         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
112         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
113         vEncSample->WaitForEOS();
114     }
115 }
116 
117 /**
118  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0020
119  * @tc.name      : h265 encode config 1280_720 surface change 640_480 1280_720 1920_1080
120  * @tc.desc      : function test
121  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0020, TestSize.Level1)122 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0020, TestSize.Level1)
123 {
124     if (!access("/system/lib64/media/", 0)) {
125         auto vEncSample = make_unique<VEncAPI11Sample>();
126         vEncSample->DEFAULT_WIDTH = 1280;
127         vEncSample->DEFAULT_HEIGHT = 720;
128         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0020.h265";
129         vEncSample->SURF_INPUT = true;
130         vEncSample->readMultiFiles = true;
131         vEncSample->fileInfos.push_back(file_640_480_rgba);
132         vEncSample->fileInfos.push_back(file_1280_720_nv12);
133         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
134         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
135         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
136         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
137         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
138         vEncSample->WaitForEOS();
139     }
140 }
141 
142 /**
143  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0030
144  * @tc.name      : h265 encode config 3840_2160 surface change 640_480 1280_536 1280_720 1920_816 1920_1080 3840_2160
145  * @tc.desc      : function test
146  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0030, TestSize.Level0)147 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0030, TestSize.Level0)
148 {
149     if (!access("/system/lib64/media/", 0)) {
150         auto vEncSample = make_unique<VEncAPI11Sample>();
151         vEncSample->DEFAULT_WIDTH = 3840;
152         vEncSample->DEFAULT_HEIGHT = 2160;
153         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0030.h265";
154         vEncSample->SURF_INPUT = true;
155         vEncSample->readMultiFiles = true;
156         vEncSample->fileInfos.push_back(file_640_480_rgba);
157         vEncSample->fileInfos.push_back(file_1280_536_nv21);
158         vEncSample->fileInfos.push_back(file_1280_720_nv12);
159         vEncSample->fileInfos.push_back(file_1920_816_rgba);
160         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
161         vEncSample->fileInfos.push_back(file_3840_2160_nv12);
162         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
163         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
164         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
165         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
166         vEncSample->WaitForEOS();
167     }
168 }
169 
170 /**
171  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0040
172  * @tc.name      : h265 encode config 1920_1080 surface change 1920_1080 1080_1920 1280_1280
173  * @tc.desc      : function test
174  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0040, TestSize.Level1)175 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0040, TestSize.Level1)
176 {
177     if (!access("/system/lib64/media/", 0)) {
178         auto vEncSample = make_unique<VEncAPI11Sample>();
179         vEncSample->DEFAULT_WIDTH = 1920;
180         vEncSample->DEFAULT_HEIGHT = 1080;
181         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0040.h265";
182         vEncSample->SURF_INPUT = true;
183         vEncSample->readMultiFiles = true;
184         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
185         vEncSample->fileInfos.push_back(file_1080_1920_nv12);
186         vEncSample->fileInfos.push_back(file_1280_1280_nv12);
187         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
188         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
189         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
190         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
191         vEncSample->WaitForEOS();
192     }
193 }
194 
195 /**
196  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0050
197  * @tc.name      : h264 encode config 320_240 surface change 640_480 1280_720 1920_1080
198  * @tc.desc      : function test
199  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0050, TestSize.Level1)200 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0050, TestSize.Level1)
201 {
202     if (!access("/system/lib64/media/", 0)) {
203         auto vEncSample = make_unique<VEncAPI11Sample>();
204         vEncSample->DEFAULT_WIDTH = 320;
205         vEncSample->DEFAULT_HEIGHT = 240;
206         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0050.h264";
207         vEncSample->SURF_INPUT = true;
208         vEncSample->readMultiFiles = true;
209         vEncSample->fileInfos.push_back(file_640_480_rgba);
210         vEncSample->fileInfos.push_back(file_1280_720_nv12);
211         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
212         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
213         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
214         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
215         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
216         vEncSample->WaitForEOS();
217     }
218 }
219 
220 /**
221  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0060
222  * @tc.name      : h264 encode config 1280_720 surface change 640_480 1280_720 1920_1080
223  * @tc.desc      : function test
224  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0060, TestSize.Level1)225 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0060, TestSize.Level1)
226 {
227     if (!access("/system/lib64/media/", 0)) {
228         auto vEncSample = make_unique<VEncAPI11Sample>();
229         vEncSample->DEFAULT_WIDTH = 1280;
230         vEncSample->DEFAULT_HEIGHT = 720;
231         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0060.h264";
232         vEncSample->SURF_INPUT = true;
233         vEncSample->readMultiFiles = true;
234         vEncSample->fileInfos.push_back(file_640_480_rgba);
235         vEncSample->fileInfos.push_back(file_1280_720_nv12);
236         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
237         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
238         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
239         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
240         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
241         vEncSample->WaitForEOS();
242     }
243 }
244 
245 /**
246  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0070
247  * @tc.name      : h264 encode config 3840_2160 surface change 640_480 1280_536 1280_720 1920_816 1920_1080 3840_2160
248  * @tc.desc      : function test
249  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0070, TestSize.Level0)250 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0070, TestSize.Level0)
251 {
252     if (!access("/system/lib64/media/", 0)) {
253         auto vEncSample = make_unique<VEncAPI11Sample>();
254         vEncSample->DEFAULT_WIDTH = 3840;
255         vEncSample->DEFAULT_HEIGHT = 2160;
256         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0070.h264";
257         vEncSample->SURF_INPUT = true;
258         vEncSample->readMultiFiles = true;
259         vEncSample->fileInfos.push_back(file_640_480_rgba);
260         vEncSample->fileInfos.push_back(file_1280_536_nv21);
261         vEncSample->fileInfos.push_back(file_1280_720_nv12);
262         vEncSample->fileInfos.push_back(file_1920_816_rgba);
263         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
264         vEncSample->fileInfos.push_back(file_3840_2160_nv12);
265         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
266         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
267         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
268         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
269         vEncSample->WaitForEOS();
270     }
271 }
272 
273 /**
274  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0080
275  * @tc.name      : h264 encode config 1920_1080 surface change 1920_1080 1080_1920 1280_1280
276  * @tc.desc      : function test
277  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0080, TestSize.Level1)278 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0080, TestSize.Level1)
279 {
280     if (!access("/system/lib64/media/", 0)) {
281         auto vEncSample = make_unique<VEncAPI11Sample>();
282         vEncSample->DEFAULT_WIDTH = 1920;
283         vEncSample->DEFAULT_HEIGHT = 1080;
284         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0080.h264";
285         vEncSample->SURF_INPUT = true;
286         vEncSample->readMultiFiles = true;
287         vEncSample->fileInfos.push_back(file_1920_1080_nv21);
288         vEncSample->fileInfos.push_back(file_1080_1920_nv12);
289         vEncSample->fileInfos.push_back(file_1280_1280_nv12);
290         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecName));
291         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
292         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
293         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
294         vEncSample->WaitForEOS();
295     }
296 }
297 
298 /**
299  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0090
300  * @tc.name      : config main10 set format 8bit surface send 8bit yuv
301  * @tc.desc      : function test
302  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0090, TestSize.Level1)303 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0090, TestSize.Level1)
304 {
305     if (!access("/system/lib64/media/", 0)) {
306         auto vEncSample = make_unique<VEncAPI11Sample>();
307         vEncSample->DEFAULT_WIDTH = 3840;
308         vEncSample->DEFAULT_HEIGHT = 2160;
309         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0090.h265";
310         vEncSample->SURF_INPUT = true;
311         vEncSample->readMultiFiles = true;
312         vEncSample->configMain10 = true;
313         vEncSample->setFormat8Bit = true;
314         vEncSample->fileInfos.push_back(file_1280_720_nv12);
315         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
316         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
317         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
318         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
319         vEncSample->WaitForEOS();
320     }
321 }
322 
323 /**
324  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0100
325  * @tc.name      : config main set format 10bit surface send 10bit yuv
326  * @tc.desc      : function test
327  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0100, TestSize.Level1)328 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0100, TestSize.Level1)
329 {
330     if (!access("/system/lib64/media/", 0)) {
331         auto vEncSample = make_unique<VEncAPI11Sample>();
332         vEncSample->DEFAULT_WIDTH = 3840;
333         vEncSample->DEFAULT_HEIGHT = 2160;
334         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0100.h265";
335         vEncSample->SURF_INPUT = true;
336         vEncSample->readMultiFiles = true;
337         vEncSample->configMain = true;
338         vEncSample->setFormat10Bit = true;
339         vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
340         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
341         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
342         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
343         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
344         vEncSample->WaitForEOS();
345     }
346 }
347 
348 /**
349  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0110
350  * @tc.name      : Not supported pixelFormat rgbx
351  * @tc.desc      : function test
352  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0110, TestSize.Level1)353 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0110, TestSize.Level1)
354 {
355     if (!access("/system/lib64/media/", 0)) {
356         auto vEncSample = make_unique<VEncAPI11Sample>();
357         vEncSample->DEFAULT_WIDTH = 3840;
358         vEncSample->DEFAULT_HEIGHT = 2160;
359         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0110.h265";
360         vEncSample->SURF_INPUT = true;
361         vEncSample->readMultiFiles = true;
362         vEncSample->setFormatRbgx = true;
363         vEncSample->fileInfos.push_back(file_640_480_rgba);
364         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
365         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
366         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
367         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
368         vEncSample->WaitForEOS();
369     }
370 }
371 
372 /**
373  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0120
374  * @tc.name      : config main set format 8bit send 10bit yuv
375  * @tc.desc      : function test
376  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0120, TestSize.Level1)377 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0120, TestSize.Level1)
378 {
379     if (!access("/system/lib64/media/", 0)) {
380         auto vEncSample = make_unique<VEncAPI11Sample>();
381         vEncSample->DEFAULT_WIDTH = 3840;
382         vEncSample->DEFAULT_HEIGHT = 2160;
383         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0120.h265";
384         vEncSample->SURF_INPUT = true;
385         vEncSample->readMultiFiles = true;
386         vEncSample->configMain = true;
387         vEncSample->setFormat8Bit = true;
388         vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
389         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
390         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
391         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
392         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
393         vEncSample->WaitForEOS();
394     }
395 }
396 
397 /**
398  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0130
399  * @tc.name      : config main10 set format 10bit send 8bit yuv
400  * @tc.desc      : function test
401  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0130, TestSize.Level1)402 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0130, TestSize.Level1)
403 {
404     if (!access("/system/lib64/media/", 0)) {
405         auto vEncSample = make_unique<VEncAPI11Sample>();
406         vEncSample->DEFAULT_WIDTH = 3840;
407         vEncSample->DEFAULT_HEIGHT = 2160;
408         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0130.h265";
409         vEncSample->SURF_INPUT = true;
410         vEncSample->readMultiFiles = true;
411         vEncSample->configMain10 = true;
412         vEncSample->setFormat10Bit = true;
413         vEncSample->fileInfos.push_back(file_1280_720_nv12);
414         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
415         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
416         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
417         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
418         vEncSample->WaitForEOS();
419     }
420 }
421 
422 /**
423  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0140
424  * @tc.name      : config main10 set format 8bit send 10bit yuv
425  * @tc.desc      : function test
426  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0140, TestSize.Level1)427 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0140, TestSize.Level1)
428 {
429     if (!access("/system/lib64/media/", 0)) {
430         auto vEncSample = make_unique<VEncAPI11Sample>();
431         vEncSample->DEFAULT_WIDTH = 3840;
432         vEncSample->DEFAULT_HEIGHT = 2160;
433         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0140.h265";
434         vEncSample->SURF_INPUT = true;
435         vEncSample->readMultiFiles = true;
436         vEncSample->configMain10 = true;
437         vEncSample->setFormat8Bit = true;
438         vEncSample->fileInfos.push_back(file_1280_720_nv12_10bit);
439         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
440         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
441         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
442         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
443         vEncSample->WaitForEOS();
444     }
445 }
446 
447 /**
448  * @tc.number    : VIDEO_ENCODE_MULTIFILE_0150
449  * @tc.name      : config main10 set format 10bit send 8bit yuv
450  * @tc.desc      : function test
451  */
HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0150, TestSize.Level1)452 HWTEST_F(HwEncFunc2NdkTest, VIDEO_ENCODE_MULTIFILE_0150, TestSize.Level1)
453 {
454     if (!access("/system/lib64/media/", 0)) {
455         auto vEncSample = make_unique<VEncAPI11Sample>();
456         vEncSample->DEFAULT_WIDTH = 3840;
457         vEncSample->DEFAULT_HEIGHT = 2160;
458         vEncSample->OUT_DIR = "/data/test/media/VIDEO_ENCODE_MULTIFILE_0150.h265";
459         vEncSample->SURF_INPUT = true;
460         vEncSample->readMultiFiles = true;
461         vEncSample->configMain10 = true;
462         vEncSample->setFormat10Bit = true;
463         vEncSample->fileInfos.push_back(file_1280_720_nv12);
464         ASSERT_EQ(AV_ERR_OK, vEncSample->CreateVideoEncoder(g_codecNameHEVC));
465         ASSERT_EQ(AV_ERR_OK, vEncSample->SetVideoEncoderCallback());
466         ASSERT_EQ(AV_ERR_OK, vEncSample->ConfigureVideoEncoder());
467         ASSERT_EQ(AV_ERR_OK, vEncSample->StartVideoEncoder());
468         vEncSample->WaitForEOS();
469     }
470 }
471 } // namespace