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