1 /*
2  * Copyright (C) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <string>
16 #include "gtest/gtest.h"
17 #include "native_avcodec_videodecoder.h"
18 #include "native_averrors.h"
19 #include "videodec_sample.h"
20 #include "videodec_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 
25 #define MAX_THREAD 16
26 
27 using namespace std;
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace testing::ext;
31 
32 namespace OHOS {
33 namespace Media {
34 class HwdecFuncNdkTest : public testing::Test {
35 public:
36     static void SetUpTestCase();
37     static void TearDownTestCase();
38     void SetUp() override;
39     void TearDown() override;
40     void InputFunc();
41     void OutputFunc();
42     void Release();
43     int32_t Stop();
44 
45 protected:
46     const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
47     const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
48     const char *INP_DIR_1080_20 = "/data/test/media/1920_1080_20M_30.h265";
49     const char *inpDirVivid = "/data/test/media/hlg_vivid_4k.h265";
50     const char *INP_DIR_VVC_1080 = "/data/test/media/1920_1080_10bit.vvc";
51     const char *inpDirVvcResolution = "/data/test/media/resolution.vvc";
52 };
53 } // namespace Media
54 } // namespace OHOS
55 
56 namespace {
57 static OH_AVCapability *cap = nullptr;
58 static OH_AVCapability *cap_hevc = nullptr;
59 static OH_AVCapability *cap_vvc = nullptr;
60 static string g_codecName = "";
61 static string g_codecNameHEVC = "";
62 static string g_codecNameVVC = "";
63 constexpr int32_t DEFAULT_WIDTH = 1920;
64 constexpr int32_t DEFAULT_HEIGHT = 1080;
65 constexpr int32_t MAX_NALU_LEN = 12000;
66 constexpr int32_t UHD_RESOLUTION[2] = {3840, 2160};
67 constexpr int32_t HD_RESOLUTION[2] = {1104, 622};
68 } // namespace
69 
SetUpTestCase()70 void HwdecFuncNdkTest::SetUpTestCase()
71 {
72     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
73     g_codecName = OH_AVCapability_GetName(cap);
74     cout << "codecname: " << g_codecName << endl;
75     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
76     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
77     cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
78     cap_vvc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_VVC, false, HARDWARE);
79     g_codecNameVVC = OH_AVCapability_GetName(cap_vvc);
80     cout << "g_codecNameVVC: " << g_codecNameVVC << endl;
81 }
TearDownTestCase()82 void HwdecFuncNdkTest::TearDownTestCase() {}
SetUp()83 void HwdecFuncNdkTest::SetUp() {}
TearDown()84 void HwdecFuncNdkTest::TearDown() {}
85 
86 namespace {
87 /**
88  * @tc.number    : VIDEO_HWDEC_FUNCTION_0200
89  * @tc.name      : create nonexist decoder
90  * @tc.desc      : function test
91  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0200, TestSize.Level1)92 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0200, TestSize.Level1)
93 {
94     OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
95     ASSERT_EQ(nullptr, vdec_);
96 }
97 
98 /**
99  * @tc.number    : VIDEO_HWDEC_FUNCTION_0300
100  * @tc.name      : test h264 asyn decode buffer, pixel foramt nv12
101  * @tc.desc      : function test
102  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0300, TestSize.Level0)103 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0300, TestSize.Level0)
104 {
105     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
106     vDecSample->INP_DIR = INP_DIR_1080_30;
107     vDecSample->DEFAULT_WIDTH = 1920;
108     vDecSample->DEFAULT_HEIGHT = 1080;
109     vDecSample->DEFAULT_FRAME_RATE = 30;
110     vDecSample->SF_OUTPUT = false;
111     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
112     vDecSample->WaitForEOS();
113     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
114 }
115 
116 /**
117  * @tc.number    : VIDEO_HWDEC_FUNCTION_0310
118  * @tc.name      : test h26 asyn decode buffer, pixel foramt nv21
119  * @tc.desc      : function test
120  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0310, TestSize.Level0)121 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0310, TestSize.Level0)
122 {
123     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
124     vDecSample->INP_DIR = INP_DIR_1080_30;
125     vDecSample->DEFAULT_WIDTH = 1920;
126     vDecSample->DEFAULT_HEIGHT = 1080;
127     vDecSample->DEFAULT_FRAME_RATE = 30;
128     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
129     vDecSample->SF_OUTPUT = false;
130     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
131     vDecSample->WaitForEOS();
132     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
133 }
134 
135 /**
136  * @tc.number    : VIDEO_HWDEC_FUNCTION_0320
137  * @tc.name      : test h265 decode buffer, pixel foramt nv12
138  * @tc.desc      : function test
139  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0320, TestSize.Level0)140 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0320, TestSize.Level0)
141 {
142     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
143     vDecSample->INP_DIR = INP_DIR_1080_30;
144     vDecSample->DEFAULT_WIDTH = 1920;
145     vDecSample->DEFAULT_HEIGHT = 1080;
146     vDecSample->DEFAULT_FRAME_RATE = 30;
147     vDecSample->SF_OUTPUT = false;
148     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
149     vDecSample->WaitForEOS();
150     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
151 }
152 
153 /**
154  * @tc.number    : VIDEO_HWDEC_FUNCTION_0330
155  * @tc.name      : test h265 decode buffer, pixel foramt nv21
156  * @tc.desc      : function test
157  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0330, TestSize.Level0)158 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0330, TestSize.Level0)
159 {
160     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
161     vDecSample->INP_DIR = INP_DIR_1080_30;
162     vDecSample->DEFAULT_WIDTH = 1920;
163     vDecSample->DEFAULT_HEIGHT = 1080;
164     vDecSample->DEFAULT_FRAME_RATE = 30;
165     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
166     vDecSample->SF_OUTPUT = false;
167     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
168     vDecSample->WaitForEOS();
169     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
170 }
171 
172 /**
173  * @tc.number    : VIDEO_HWDEC_FUNCTION_0400
174  * @tc.name      : test h264 asyn decode surface, pixel foramt nv12
175  * @tc.desc      : function test
176  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0400, TestSize.Level0)177 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0400, TestSize.Level0)
178 {
179     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
180     vDecSample->INP_DIR = INP_DIR_1080_30;
181     vDecSample->SF_OUTPUT = true;
182     vDecSample->DEFAULT_WIDTH = 1920;
183     vDecSample->DEFAULT_HEIGHT = 1080;
184     vDecSample->DEFAULT_FRAME_RATE = 30;
185     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
186     vDecSample->WaitForEOS();
187     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
188 }
189 
190 /**
191  * @tc.number    : VIDEO_HWDEC_FUNCTION_0410
192  * @tc.name      : test h264 asyn decode surface, pixel foramt nv21
193  * @tc.desc      : function test
194  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0410, TestSize.Level0)195 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0410, TestSize.Level0)
196 {
197     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
198     vDecSample->INP_DIR = INP_DIR_1080_30;
199     vDecSample->SF_OUTPUT = true;
200     vDecSample->DEFAULT_WIDTH = 1920;
201     vDecSample->DEFAULT_HEIGHT = 1080;
202     vDecSample->DEFAULT_FRAME_RATE = 30;
203     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
204     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
205     vDecSample->WaitForEOS();
206     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
207 }
208 
209 /**
210  * @tc.number    : VIDEO_HWDEC_FUNCTION_0420
211  * @tc.name      : test h265 asyn decode surface, pixel foramt nv12
212  * @tc.desc      : function test
213  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0420, TestSize.Level0)214 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0420, TestSize.Level0)
215 {
216     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
217     vDecSample->INP_DIR = INP_DIR_1080_30;
218     vDecSample->SF_OUTPUT = true;
219     vDecSample->DEFAULT_WIDTH = 1920;
220     vDecSample->DEFAULT_HEIGHT = 1080;
221     vDecSample->DEFAULT_FRAME_RATE = 30;
222     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
223     vDecSample->WaitForEOS();
224     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
225 }
226 
227 /**
228  * @tc.number    : VIDEO_HWDEC_FUNCTION_0430
229  * @tc.name      : test h265 asyn decode surface, pixel foramt nv21
230  * @tc.desc      : function test
231  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0430, TestSize.Level0)232 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0430, TestSize.Level0)
233 {
234     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
235     vDecSample->INP_DIR = INP_DIR_1080_30;
236     vDecSample->SF_OUTPUT = true;
237     vDecSample->DEFAULT_WIDTH = 1920;
238     vDecSample->DEFAULT_HEIGHT = 1080;
239     vDecSample->DEFAULT_FRAME_RATE = 30;
240     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
241     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
242     vDecSample->WaitForEOS();
243     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
244 }
245 
246 /**
247  * @tc.number    : VIDEO_HWDEC_FUNCTION_0700
248  * @tc.name      : test set EOS when last frame
249  * @tc.desc      : function test
250  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0700, TestSize.Level1)251 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0700, TestSize.Level1)
252 {
253     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
254     vDecSample->INP_DIR = INP_DIR_1080_30;
255     vDecSample->DEFAULT_WIDTH = 1920;
256     vDecSample->DEFAULT_HEIGHT = 1080;
257     vDecSample->DEFAULT_FRAME_RATE = 30;
258     vDecSample->SF_OUTPUT = false;
259     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
260     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
261     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
262     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
263     vDecSample->WaitForEOS();
264     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
265 }
266 
267 /**
268  * @tc.number    : VIDEO_HWDEC_FUNCTION_0800
269  * @tc.name      : test set EOS before last frame then stop
270  * @tc.desc      : function test
271  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0800, TestSize.Level1)272 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0800, TestSize.Level1)
273 {
274     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
275     vDecSample->INP_DIR = INP_DIR_1080_30;
276     vDecSample->DEFAULT_WIDTH = 1920;
277     vDecSample->DEFAULT_HEIGHT = 1080;
278     vDecSample->DEFAULT_FRAME_RATE = 30;
279     vDecSample->SF_OUTPUT = false;
280     vDecSample->BEFORE_EOS_INPUT = true;
281     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
282     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
283     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
284     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
285     vDecSample->WaitForEOS();
286     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
287 }
288 
289 /**
290  * @tc.number    : VIDEO_HWDEC_FUNCTION_0900
291  * @tc.name      : test set EOS before last frame then input frames
292  * @tc.desc      : function test
293  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0900, TestSize.Level1)294 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0900, TestSize.Level1)
295 {
296     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
297     vDecSample->INP_DIR = INP_DIR_1080_30;
298     vDecSample->DEFAULT_WIDTH = 1920;
299     vDecSample->DEFAULT_HEIGHT = 1080;
300     vDecSample->DEFAULT_FRAME_RATE = 30;
301     vDecSample->SF_OUTPUT = false;
302     vDecSample->BEFORE_EOS_INPUT_INPUT = true;
303     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
304     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
305     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
306     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
307     vDecSample->WaitForEOS();
308     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
309 }
310 
311 /**
312  * @tc.number    : VIDEO_HWDEC_FUNCTION_1000
313  * @tc.name      : test reconfigure for new file with one decoder
314  * @tc.desc      : function test
315  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1000, TestSize.Level1)316 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1000, TestSize.Level1)
317 {
318     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
319     vDecSample->INP_DIR = INP_DIR_1080_30;
320     vDecSample->DEFAULT_WIDTH = 1920;
321     vDecSample->DEFAULT_HEIGHT = 1080;
322     vDecSample->DEFAULT_FRAME_RATE = 30;
323     vDecSample->SF_OUTPUT = false;
324     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
325     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
326     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
327     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
328     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
329     vDecSample->WaitForEOS();
330     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
331     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
332     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
333     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
334     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
335     vDecSample->WaitForEOS();
336     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
337 }
338 
339 /**
340  * @tc.number    : VIDEO_HWDEC_FUNCTION_1100
341  * @tc.name      : test reconfigure for new file with the recreated decoder
342  * @tc.desc      : function test
343  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1100, TestSize.Level1)344 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1100, TestSize.Level1)
345 {
346     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
347     vDecSample->INP_DIR = INP_DIR_1080_30;
348     vDecSample->DEFAULT_WIDTH = 1920;
349     vDecSample->DEFAULT_HEIGHT = 1080;
350     vDecSample->DEFAULT_FRAME_RATE = 30;
351     vDecSample->SF_OUTPUT = false;
352     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
353     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
354     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
355     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
356     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
357     vDecSample->WaitForEOS();
358     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
359     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
360     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
361     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
362     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
363     vDecSample->WaitForEOS();
364     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
365 }
366 
367 /**
368  * @tc.number    : VIDEO_HWDEC_FUNCTION_1200
369  * @tc.name      : repeat start and stop 5 times before EOS
370  * @tc.desc      : function test
371  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1200, TestSize.Level2)372 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1200, TestSize.Level2)
373 {
374     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
375     vDecSample->INP_DIR = INP_DIR_1080_30;
376     vDecSample->DEFAULT_WIDTH = 1920;
377     vDecSample->DEFAULT_HEIGHT = 1080;
378     vDecSample->DEFAULT_FRAME_RATE = 30;
379     vDecSample->SF_OUTPUT = false;
380     vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
381     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
382     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
383     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
384     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
385     vDecSample->WaitForEOS();
386     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
387 }
388 
389 /**
390  * @tc.number    : VIDEO_HWDEC_FUNCTION_1300
391  * @tc.name      : repeat start and flush 5 times before EOS
392  * @tc.desc      : function test
393  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1300, TestSize.Level2)394 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1300, TestSize.Level2)
395 {
396     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
397     vDecSample->INP_DIR = INP_DIR_1080_30;
398     vDecSample->DEFAULT_WIDTH = 1920;
399     vDecSample->DEFAULT_HEIGHT = 1080;
400     vDecSample->DEFAULT_FRAME_RATE = 30;
401     vDecSample->SF_OUTPUT = false;
402     vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
403     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
404     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
405     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
406     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
407     vDecSample->WaitForEOS();
408     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
409 }
410 
411 /**
412  * @tc.number    : VIDEO_HWDEC_FUNCTION_1400
413  * @tc.name      : set larger width and height
414  * @tc.desc      : function test
415  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1400, TestSize.Level2)416 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1400, TestSize.Level2)
417 {
418     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
419     vDecSample->INP_DIR = INP_DIR_720_30;
420     vDecSample->DEFAULT_WIDTH = 1920;
421     vDecSample->DEFAULT_HEIGHT = 1080;
422     vDecSample->DEFAULT_FRAME_RATE = 30;
423     vDecSample->SF_OUTPUT = false;
424     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
425     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
426     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
427     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
428     vDecSample->WaitForEOS();
429     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
430 }
431 
432 /**
433  * @tc.number    : VIDEO_HWDEC_FUNCTION_1600
434  * @tc.name      : 265 decode
435  * @tc.desc      : function test
436  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1600, TestSize.Level2)437 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1600, TestSize.Level2)
438 {
439     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
440     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
441     vDecSample->DEFAULT_WIDTH = 1920;
442     vDecSample->DEFAULT_HEIGHT = 1080;
443     vDecSample->DEFAULT_FRAME_RATE = 30;
444     vDecSample->SF_OUTPUT = false;
445     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
446     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
447     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
448     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
449     vDecSample->WaitForEOS();
450     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
451 }
452 
453 /**
454  * @tc.number    : VIDEO_HWDEC_FUNCTION_1700
455  * @tc.name      : resolution change
456  * @tc.desc      : function test
457  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1700, TestSize.Level2)458 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1700, TestSize.Level2)
459 {
460     if (g_codecName.find("hisi") != string::npos) {
461         auto vDecSample = make_shared<VDecNdkSample>();
462         vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
463         vDecSample->DEFAULT_WIDTH = 1104;
464         vDecSample->DEFAULT_HEIGHT = 622;
465         vDecSample->DEFAULT_FRAME_RATE = 30;
466         vDecSample->SF_OUTPUT = false;
467         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
468         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
469         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
470         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
471         vDecSample->WaitForEOS();
472         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
473     } else {
474         cout << "hardware encoder is rk,skip." << endl;
475     }
476 }
477 /**
478  * @tc.number    : SURF_CHANGE_FUNC_001
479  * @tc.name      : surf change in normal state
480  * @tc.desc      : function test
481  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)482 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)
483 {
484     auto vDecSample = make_shared<VDecNdkSample>();
485     vDecSample->INP_DIR = INP_DIR_1080_30;
486     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
487     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
488     vDecSample->DEFAULT_FRAME_RATE = 30;
489     vDecSample->SF_OUTPUT = true;
490     vDecSample->autoSwitchSurface = true;
491     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
492     vDecSample->sleepOnFPS = true;
493     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
494     vDecSample->WaitForEOS();
495     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
496     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
497     ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
498     ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
499 }
500 /**
501  * @tc.number    : SURF_CHANGE_FUNC_002
502  * @tc.name      : surf change in flushed state
503  * @tc.desc      : function test
504  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)505 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)
506 {
507     auto vDecSample = make_shared<VDecNdkSample>();
508     vDecSample->INP_DIR = INP_DIR_1080_30;
509     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
510     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
511     vDecSample->DEFAULT_FRAME_RATE = 30;
512     vDecSample->SF_OUTPUT = true;
513     vDecSample->autoSwitchSurface = true;
514     vDecSample->sleepOnFPS = true;
515     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
516     ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
517     ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
518     ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
519     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
520 }
521 /**
522  * @tc.number    : SURF_CHANGE_FUNC_003
523  * @tc.name      : surf change in buffer mode
524  * @tc.desc      : function test
525  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)526 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)
527 {
528     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
529     vDecSample->INP_DIR = INP_DIR_1080_30;
530     vDecSample->DEFAULT_WIDTH = 1920;
531     vDecSample->DEFAULT_HEIGHT = 1080;
532     vDecSample->DEFAULT_FRAME_RATE = 30;
533     vDecSample->SF_OUTPUT = false;
534     vDecSample->CreateSurface();
535     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
536     ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
537     vDecSample->WaitForEOS();
538     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
539 }
540 /**
541  * @tc.number    : SURF_CHANGE_FUNC_004
542  * @tc.name      : repeat call setSurface fastly
543  * @tc.desc      : function test
544  */
HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)545 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)
546 {
547     auto vDecSample = make_shared<VDecNdkSample>();
548     vDecSample->INP_DIR = INP_DIR_1080_30;
549     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
550     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
551     vDecSample->DEFAULT_FRAME_RATE = 30;
552     vDecSample->SF_OUTPUT = true;
553     vDecSample->autoSwitchSurface = true;
554     vDecSample->sleepOnFPS = true;
555     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
556     ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
557     vDecSample->WaitForEOS();
558 }
559 
560 /**
561  * @tc.number    : OUTPUT_DECS_FUNC_001
562  * @tc.name      : get decode output descriptions h264
563  * @tc.desc      : function test
564  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_001, TestSize.Level0)565 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_001, TestSize.Level0)
566 {
567     if (g_codecName.find("hisi") != string::npos) {
568         auto vDecSample = make_shared<VDecNdkSample>();
569         vDecSample->INP_DIR = "/data/test/media/1920x1080.h264";
570         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
571         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
572         vDecSample->DEFAULT_FRAME_RATE = 30;
573         vDecSample->needCheckOutputDesc = true;
574         vDecSample->expectCropTop = 0;
575         vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
576         vDecSample->expectCropLeft = 0;
577         vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
578 
579         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
580         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
581         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
582         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
583         vDecSample->WaitForEOS();
584         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
585     } else {
586         cout << "hardware encoder is rk,skip." << endl;
587     }
588 }
589 /**
590  * @tc.number    : OUTPUT_DECS_FUNC_002
591  * @tc.name      : get decode output descriptions h265
592  * @tc.desc      : function test
593  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_002, TestSize.Level0)594 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_002, TestSize.Level0)
595 {
596     if (g_codecName.find("hisi") != string::npos) {
597         auto vDecSample = make_shared<VDecNdkSample>();
598         vDecSample->INP_DIR = "/data/test/media/1920x1080.h265";
599         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
600         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
601         vDecSample->DEFAULT_FRAME_RATE = 30;
602         vDecSample->needCheckOutputDesc = true;
603         vDecSample->expectCropTop = 0;
604         vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
605         vDecSample->expectCropLeft = 0;
606         vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
607 
608         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
609         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
610         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
611         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
612         vDecSample->WaitForEOS();
613         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
614     } else {
615         cout << "hardware encoder is rk,skip." << endl;
616     }
617 }
618 /**
619  * @tc.number    : OUTPUT_DECS_FUNC_003
620  * @tc.name      : get decode output descriptions h264 ,4k
621  * @tc.desc      : function test
622  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_003, TestSize.Level0)623 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_003, TestSize.Level0)
624 {
625     if (g_codecName.find("hisi") != string::npos) {
626         auto vDecSample = make_shared<VDecNdkSample>();
627         vDecSample->INP_DIR = "/data/test/media/3840x2160.h264";
628         vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
629         vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
630         vDecSample->DEFAULT_FRAME_RATE = 30;
631         vDecSample->needCheckOutputDesc = true;
632         vDecSample->expectCropTop = 0;
633         vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
634         vDecSample->expectCropLeft = 0;
635         vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
636 
637         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
638         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
639         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
640         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
641         vDecSample->WaitForEOS();
642         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
643     } else {
644         cout << "hardware encoder is rk,skip." << endl;
645     }
646 }
647 /**
648  * @tc.number    : OUTPUT_DECS_FUNC_004
649  * @tc.name      : get decode output descriptions h265 ,4k
650  * @tc.desc      : function test
651  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_004, TestSize.Level0)652 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_004, TestSize.Level0)
653 {
654     if (g_codecName.find("hisi") != string::npos) {
655         auto vDecSample = make_shared<VDecNdkSample>();
656         vDecSample->INP_DIR = "/data/test/media/3840x2160.h265";
657         vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
658         vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
659         vDecSample->DEFAULT_FRAME_RATE = 30;
660         vDecSample->needCheckOutputDesc = true;
661         vDecSample->expectCropTop = 0;
662         vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
663         vDecSample->expectCropLeft = 0;
664         vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
665 
666         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
667         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
668         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
669         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
670         vDecSample->WaitForEOS();
671         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
672     } else {
673         cout << "hardware encoder is rk,skip." << endl;
674     }
675 }
676 /**
677  * @tc.number    : OUTPUT_DECS_FUNC_005
678  * @tc.name      : get decode output descriptions h264 ,crop size
679  * @tc.desc      : function test
680  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_005, TestSize.Level0)681 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_005, TestSize.Level0)
682 {
683     if (g_codecName.find("hisi") != string::npos) {
684         auto vDecSample = make_shared<VDecNdkSample>();
685         vDecSample->INP_DIR = "/data/test/media/1104x622.h264";
686         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
687         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
688         vDecSample->DEFAULT_FRAME_RATE = 30;
689         vDecSample->needCheckOutputDesc = true;
690         vDecSample->expectCropTop = 0;
691         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
692         vDecSample->expectCropLeft = 0;
693         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
694 
695         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
696         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
697         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
698         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
699         vDecSample->WaitForEOS();
700         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
701     } else {
702         cout << "hardware encoder is rk,skip." << endl;
703     }
704 }
705 /**
706  * @tc.number    : OUTPUT_DECS_FUNC_006
707  * @tc.name      : get decode output descriptions h265 ,crop size
708  * @tc.desc      : function test
709  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_006, TestSize.Level0)710 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_006, TestSize.Level0)
711 {
712     if (g_codecName.find("hisi") != string::npos) {
713         auto vDecSample = make_shared<VDecNdkSample>();
714         vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
715         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
716         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
717         vDecSample->DEFAULT_FRAME_RATE = 30;
718         vDecSample->needCheckOutputDesc = true;
719         vDecSample->expectCropTop = 0;
720         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
721         vDecSample->expectCropLeft = 0;
722         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
723 
724         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
725         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
726         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
727         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
728         vDecSample->WaitForEOS();
729         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
730     } else {
731         cout << "hardware encoder is rk,skip." << endl;
732     }
733 }
734 /**
735  * @tc.number    : OUTPUT_DECS_FUNC_007
736  * @tc.name      : get decode output descriptions h265 ,resolution change
737  * @tc.desc      : function test
738  */
HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_007, TestSize.Level0)739 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_007, TestSize.Level0)
740 {
741     if (g_codecName.find("hisi") != string::npos) {
742         auto vDecSample = make_shared<VDecNdkSample>();
743         vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
744         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
745         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
746         vDecSample->DEFAULT_FRAME_RATE = 30;
747         vDecSample->isResChangeStream = true;
748         vDecSample->expectCropTop = 0;
749         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
750         vDecSample->expectCropLeft = 0;
751         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
752 
753         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
754         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
755         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
756         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
757         vDecSample->WaitForEOS();
758         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
759     } else {
760         cout << "hardware encoder is rk,skip." << endl;
761     }
762 }
763 
764 /**
765  * @tc.number    : MAX_INPUT_SIZE_CHECK_001
766  * @tc.name      : MaxInputSize value incorrect
767  * @tc.desc      : function test
768  */
HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)769 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)
770 {
771     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
772     vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
773     vDecSample->DEFAULT_WIDTH = 1920;
774     vDecSample->DEFAULT_HEIGHT = 1080;
775     vDecSample->DEFAULT_FRAME_RATE = 30;
776     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
777     vDecSample->maxInputSize = -1;
778     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
779     vDecSample->WaitForEOS();
780     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
781 }
782 
783 /**
784  * @tc.number    : MAX_INPUT_SIZE_CHECK_002
785  * @tc.name      : MaxInputSize value incorrect
786  * @tc.desc      : function test
787  */
HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)788 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)
789 {
790     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
791     vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
792     vDecSample->DEFAULT_WIDTH = 1920;
793     vDecSample->DEFAULT_HEIGHT = 1080;
794     vDecSample->DEFAULT_FRAME_RATE = 30;
795     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
796     vDecSample->maxInputSize = INT_MAX;
797     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
798     vDecSample->WaitForEOS();
799     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
800 }
801 
802 /**
803  * @tc.number    : MAX_INPUT_SIZE_CHECK_003
804  * @tc.name      : MaxInputSize value normal
805  * @tc.desc      : function test
806  */
HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_003, TestSize.Level0)807 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_003, TestSize.Level0)
808 {
809     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
810     vDecSample->INP_DIR = "/data/test/media/1104x622.h264";
811     vDecSample->DEFAULT_WIDTH = 1108;
812     vDecSample->DEFAULT_HEIGHT = 622;
813     vDecSample->DEFAULT_FRAME_RATE = 30;
814     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
815     vDecSample->maxInputSize = MAX_NALU_LEN;
816     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
817     vDecSample->WaitForEOS();
818     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
819 }
820 /**
821  * @tc.number    : MAX_INPUT_SIZE_CHECK_004
822  * @tc.name      : MaxInputSize value incorrect hevc
823  * @tc.desc      : function test
824  */
HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_004, TestSize.Level0)825 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_004, TestSize.Level0)
826 {
827     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
828     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
829     vDecSample->DEFAULT_WIDTH = 1920;
830     vDecSample->DEFAULT_HEIGHT = 1080;
831     vDecSample->DEFAULT_FRAME_RATE = 30;
832     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
833     vDecSample->maxInputSize = -1;
834     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
835     vDecSample->WaitForEOS();
836     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
837 }
838 
839 /**
840  * @tc.number    : MAX_INPUT_SIZE_CHECK_005
841  * @tc.name      : MaxInputSize value incorrect
842  * @tc.desc      : function test
843  */
HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_005, TestSize.Level0)844 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_005, TestSize.Level0)
845 {
846     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
847     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
848     vDecSample->DEFAULT_WIDTH = 1920;
849     vDecSample->DEFAULT_HEIGHT = 1080;
850     vDecSample->DEFAULT_FRAME_RATE = 30;
851     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
852     vDecSample->maxInputSize = INT_MAX;
853     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
854     vDecSample->WaitForEOS();
855     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
856 }
857 
858 /**
859  * @tc.number    : MAX_INPUT_SIZE_CHECK_006
860  * @tc.name      : MaxInputSize value normal
861  * @tc.desc      : function test
862  */
HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_006, TestSize.Level0)863 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_006, TestSize.Level0)
864 {
865     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
866     vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
867     vDecSample->DEFAULT_WIDTH = 1108;
868     vDecSample->DEFAULT_HEIGHT = 622;
869     vDecSample->DEFAULT_FRAME_RATE = 30;
870     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
871     vDecSample->maxInputSize = MAX_NALU_LEN;
872     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
873     vDecSample->WaitForEOS();
874     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
875 }
876 
877 /**
878  * @tc.number    : FLUSH_CHECK_001
879  * @tc.name      : Compare the flush frame with the normal process frame
880  * @tc.desc      : function test
881  */
HWTEST_F(HwdecFuncNdkTest, FLUSH_CHECK_001, TestSize.Level0)882 HWTEST_F(HwdecFuncNdkTest, FLUSH_CHECK_001, TestSize.Level0)
883 {
884     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
885     vDecSample->INP_DIR = INP_DIR_1080_30;
886     vDecSample->DEFAULT_WIDTH = 1920;
887     vDecSample->DEFAULT_HEIGHT = 1080;
888     vDecSample->DEFAULT_FRAME_RATE = 30;
889     vDecSample->SF_OUTPUT = false;
890     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
891     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
892     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
893     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
894     vDecSample->WaitForEOS();
895     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
896     cout << "--vDecSample--" << vDecSample->outCount << endl;
897     shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
898     vDecSample1->INP_DIR = INP_DIR_1080_30;
899     vDecSample1->DEFAULT_WIDTH = 1920;
900     vDecSample1->DEFAULT_HEIGHT = 1080;
901     vDecSample1->DEFAULT_FRAME_RATE = 30;
902     vDecSample1->SF_OUTPUT = false;
903     vDecSample1->REPEAT_START_FLUSH_BEFORE_EOS = 1;
904     ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
905     ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
906     ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
907     ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
908     vDecSample1->WaitForEOS();
909     ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
910     cout << "--Flush--" << vDecSample1->outCount << endl;
911     ASSERT_EQ(vDecSample->outCount, vDecSample1->outCount);
912 }
913 
914 /**
915  * @tc.number    : VIDEO_HWDEC_FUNCTION_ATTIME_0010
916  * @tc.name      : test h264 asyn decode surface,use at time
917  * @tc.desc      : function test
918  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0010, TestSize.Level0)919 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0010, TestSize.Level0)
920 {
921     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
922     vDecSample->INP_DIR = INP_DIR_720_30;
923     vDecSample->SF_OUTPUT = true;
924     vDecSample->DEFAULT_WIDTH = 1280;
925     vDecSample->DEFAULT_HEIGHT = 720;
926     vDecSample->DEFAULT_FRAME_RATE = 30;
927     vDecSample->rsAtTime = true;
928     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
929     vDecSample->WaitForEOS();
930     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
931 }
932 
933 /**
934  * @tc.number    : VIDEO_HWDEC_FUNCTION_ATTIME_0011
935  * @tc.name      : test h265 asyn decode surface,use at time
936  * @tc.desc      : function test
937  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0011, TestSize.Level1)938 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0011, TestSize.Level1)
939 {
940     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
941     vDecSample->INP_DIR = INP_DIR_1080_20;
942     vDecSample->SF_OUTPUT = true;
943     vDecSample->DEFAULT_WIDTH = 1920;
944     vDecSample->DEFAULT_HEIGHT = 1080;
945     vDecSample->DEFAULT_FRAME_RATE = 30;
946     vDecSample->rsAtTime = true;
947     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
948     vDecSample->WaitForEOS();
949     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
950 }
951 
952 /**
953  * @tc.number    : VIDEO_HWDEC_FUNCTION_ATTIME_0012
954  * @tc.name      : test h265 10bit asyn decode surface,use at time
955  * @tc.desc      : function test
956  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0012, TestSize.Level1)957 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0012, TestSize.Level1)
958 {
959     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
960     vDecSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN;
961     vDecSample->INP_DIR = inpDirVivid;
962     vDecSample->SF_OUTPUT = true;
963     vDecSample->DEFAULT_WIDTH = 3840;
964     vDecSample->DEFAULT_HEIGHT = 2160;
965     vDecSample->DEFAULT_FRAME_RATE = 30;
966     vDecSample->rsAtTime = true;
967     vDecSample->useHDRSource = true;
968     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
969     vDecSample->WaitForEOS();
970     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
971 }
972 
973 /**
974  * @tc.number    : VIDEO_HWDEC_FUNCTION_1410
975  * @tc.name      : Increase frame rate judgment
976  * @tc.desc      : function test
977  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1410, TestSize.Level2)978 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1410, TestSize.Level2)
979 {
980     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
981     vDecSample->INP_DIR = INP_DIR_720_30;
982     vDecSample->OUT_DIR = "/data/test/media/HW_720_30.yuv";
983     vDecSample->DEFAULT_WIDTH = 1280;
984     vDecSample->DEFAULT_HEIGHT = 720;
985     vDecSample->DEFAULT_FRAME_RATE = 30;
986     vDecSample->SF_OUTPUT = false;
987     vDecSample->outputYuvFlag = true;
988     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
989     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
990     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
991     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
992     vDecSample->WaitForEOS();
993     ASSERT_EQ(101, vDecSample->outFrameCount);
994     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
995 }
996 
997 /**
998  * @tc.number    : VIDEO_HWDEC_FUNCTION_1420
999  * @tc.name      : Increase frame rate judgment
1000  * @tc.desc      : function test
1001  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1420, TestSize.Level2)1002 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1420, TestSize.Level2)
1003 {
1004     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1005     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
1006     vDecSample->OUT_DIR = "/data/test/media/HW_1920_1080_20M_30.yuv";
1007     vDecSample->DEFAULT_WIDTH = 1920;
1008     vDecSample->DEFAULT_HEIGHT = 1080;
1009     vDecSample->DEFAULT_FRAME_RATE = 30;
1010     vDecSample->SF_OUTPUT = false;
1011     vDecSample->outputYuvFlag = true;
1012     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
1013     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1014     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1015     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1016     vDecSample->WaitForEOS();
1017     ASSERT_EQ(501, vDecSample->outFrameCount);
1018     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1019 }
1020 
1021 /**
1022  * @tc.number    : VIDEO_DECODE_VVC_0100
1023  * @tc.name      : decode vvc buffer
1024  * @tc.desc      : function test
1025  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0100, TestSize.Level0)1026 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0100, TestSize.Level0)
1027 {
1028     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1029         auto vDecSample = make_shared<VDecAPI11Sample>();
1030         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1031         vDecSample->DEFAULT_WIDTH = 1920;
1032         vDecSample->DEFAULT_HEIGHT = 1080;
1033         vDecSample->DEFAULT_FRAME_RATE = 30;
1034         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1035         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1036         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1037         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1038         vDecSample->WaitForEOS();
1039         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1040     }
1041 }
1042 
1043 /**
1044  * @tc.number    : VIDEO_DECODE_VVC_0200
1045  * @tc.name      : decode vvc surface
1046  * @tc.desc      : function test
1047  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0200, TestSize.Level0)1048 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0200, TestSize.Level0)
1049 {
1050     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1051         auto vDecSample = make_shared<VDecAPI11Sample>();
1052         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1053         vDecSample->DEFAULT_WIDTH = 1920;
1054         vDecSample->DEFAULT_HEIGHT = 1080;
1055         vDecSample->DEFAULT_FRAME_RATE = 30;
1056         vDecSample->SF_OUTPUT = true;
1057         vDecSample->sleepOnFPS = true;
1058         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameVVC));
1059         vDecSample->WaitForEOS();
1060         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1061     }
1062 }
1063 
1064 /**
1065  * @tc.number    : VIDEO_DECODE_VVC_0300
1066  * @tc.name      : decode vvc switch surface
1067  * @tc.desc      : function test
1068  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0300, TestSize.Level1)1069 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0300, TestSize.Level1)
1070 {
1071     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1072         auto vDecSample = make_shared<VDecAPI11Sample>();
1073         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1074         vDecSample->DEFAULT_WIDTH = 1920;
1075         vDecSample->DEFAULT_HEIGHT = 1080;
1076         vDecSample->DEFAULT_FRAME_RATE = 30;
1077         vDecSample->SF_OUTPUT = true;
1078         vDecSample->autoSwitchSurface = true;
1079         vDecSample->sleepOnFPS = true;
1080         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameVVC));
1081         vDecSample->WaitForEOS();
1082         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1083     }
1084 }
1085 
1086 /**
1087  * @tc.number    : VIDEO_DECODE_VVC_0400
1088  * @tc.name      : decode vvc resolution change
1089  * @tc.desc      : function test
1090  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0400, TestSize.Level2)1091 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0400, TestSize.Level2)
1092 {
1093     if (access(inpDirVvcResolution, F_OK) == 0) {
1094         auto vDecSample = make_shared<VDecAPI11Sample>();
1095         vDecSample->INP_DIR = inpDirVvcResolution;
1096         vDecSample->DEFAULT_WIDTH = 1104;
1097         vDecSample->DEFAULT_HEIGHT = 622;
1098         vDecSample->DEFAULT_FRAME_RATE = 30;
1099         vDecSample->SF_OUTPUT = false;
1100         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1101         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1102         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1103         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1104         vDecSample->WaitForEOS();
1105         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1106     }
1107 }
1108 
1109 /**
1110  * @tc.number    : VIDEO_DECODE_VVC_0500
1111  * @tc.name      : decode vvc 10bit hdrVivid
1112  * @tc.desc      : function test
1113  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0500, TestSize.Level1)1114 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0500, TestSize.Level1)
1115 {
1116     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1117         auto vDecSample = make_shared<VDecAPI11Sample>();
1118         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1119         vDecSample->DEFAULT_WIDTH = 1920;
1120         vDecSample->DEFAULT_HEIGHT = 1080;
1121         vDecSample->DEFAULT_FRAME_RATE = 30;
1122         vDecSample->SF_OUTPUT = false;
1123         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1124         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1125         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1126         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1127         vDecSample->WaitForEOS();
1128         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1129     }
1130 }
1131 
1132 /**
1133  * @tc.number    : VIDEO_DECODE_VVC_0600
1134  * @tc.name      : decode vvc surf change in normal state
1135  * @tc.desc      : function test
1136  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0600, TestSize.Level2)1137 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0600, TestSize.Level2)
1138 {
1139     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1140         auto vDecSample = make_shared<VDecAPI11Sample>();
1141         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1142         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1143         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1144         vDecSample->DEFAULT_FRAME_RATE = 30;
1145         vDecSample->SF_OUTPUT = true;
1146         vDecSample->autoSwitchSurface = true;
1147         vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1148         vDecSample->sleepOnFPS = true;
1149         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameVVC));
1150         vDecSample->WaitForEOS();
1151         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1152         ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
1153         ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
1154         ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
1155     }
1156 }
1157 
1158 /**
1159  * @tc.number    : VIDEO_DECODE_VVC_0700
1160  * @tc.name      : decode vvc surf change in flushed state
1161  * @tc.desc      : function test
1162  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0700, TestSize.Level2)1163 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0700, TestSize.Level2)
1164 {
1165     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1166         auto vDecSample = make_shared<VDecAPI11Sample>();
1167         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1168         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1169         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1170         vDecSample->DEFAULT_FRAME_RATE = 30;
1171         vDecSample->SF_OUTPUT = true;
1172         vDecSample->autoSwitchSurface = true;
1173         vDecSample->sleepOnFPS = true;
1174         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameVVC));
1175         ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1176         ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1177         ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
1178         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1179     }
1180 }
1181 
1182 /**
1183  * @tc.number    : VIDEO_DECODE_VVC_0800
1184  * @tc.name      : decode vvc surf change in buffer mode
1185  * @tc.desc      : function test
1186  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0800, TestSize.Level2)1187 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0800, TestSize.Level2)
1188 {
1189     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1190         auto vDecSample = make_shared<VDecAPI11Sample>();
1191         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1192         vDecSample->DEFAULT_WIDTH = 1920;
1193         vDecSample->DEFAULT_HEIGHT = 1080;
1194         vDecSample->DEFAULT_FRAME_RATE = 30;
1195         vDecSample->SF_OUTPUT = false;
1196         vDecSample->CreateSurface();
1197         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameVVC));
1198         ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
1199         vDecSample->WaitForEOS();
1200         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1201     }
1202 }
1203 
1204 /**
1205  * @tc.number    : VIDEO_DECODE_VVC_0900
1206  * @tc.name      : decode vvc get decode output descriptions h265
1207  * @tc.desc      : function test
1208  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0900, TestSize.Level2)1209 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_0900, TestSize.Level2)
1210 {
1211     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1212         auto vDecSample = make_shared<VDecAPI11Sample>();
1213         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1214         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1215         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1216         vDecSample->DEFAULT_FRAME_RATE = 30;
1217         vDecSample->needCheckOutputDesc = true;
1218         vDecSample->expectCropTop = 0;
1219         vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
1220         vDecSample->expectCropLeft = 0;
1221         vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
1222 
1223         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1224         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1225         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1226         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1227         vDecSample->WaitForEOS();
1228         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1229     }
1230 }
1231 
1232 /**
1233  * @tc.number    : VIDEO_DECODE_VVC_1000
1234  * @tc.name      : decode vvc enable low latency
1235  * @tc.desc      : function test
1236  */
HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_1000, TestSize.Level2)1237 HWTEST_F(HwdecFuncNdkTest, VIDEO_DECODE_VVC_1000, TestSize.Level2)
1238 {
1239     if (access(INP_DIR_VVC_1080, F_OK) == 0) {
1240         auto vDecSample = make_shared<VDecNdkSample>();
1241         vDecSample->INP_DIR = INP_DIR_VVC_1080;
1242         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1243         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1244         vDecSample->DEFAULT_FRAME_RATE = 30;
1245         vDecSample->enableLowLatency = true;
1246         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameVVC));
1247         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1248         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1249         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1250         vDecSample->WaitForEOS();
1251         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1252     }
1253 }
1254 } // namespace