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 };
51 } // namespace Media
52 } // namespace OHOS
53 
54 namespace {
55 static OH_AVCapability *cap = nullptr;
56 static OH_AVCapability *cap_hevc = nullptr;
57 static string g_codecName = "";
58 static string g_codecNameHEVC = "";
59 constexpr int32_t DEFAULT_WIDTH = 1920;
60 constexpr int32_t DEFAULT_HEIGHT = 1080;
61 constexpr int32_t MAX_NALU_LEN = 12000;
62 constexpr int32_t UHD_RESOLUTION[2] = {3840, 2160};
63 constexpr int32_t HD_RESOLUTION[2] = {1104, 622};
64 } // namespace
65 
SetUpTestCase()66 void HwdecFuncNdkTest::SetUpTestCase()
67 {
68     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
69     g_codecName = OH_AVCapability_GetName(cap);
70     cout << "codecname: " << g_codecName << endl;
71     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
72     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
73     cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
74 }
TearDownTestCase()75 void HwdecFuncNdkTest::TearDownTestCase() {}
SetUp()76 void HwdecFuncNdkTest::SetUp() {}
TearDown()77 void HwdecFuncNdkTest::TearDown() {}
78 
79 namespace {
80 /**
81  * @tc.number    : VIDEO_HWDEC_FUNCTION_0200
82  * @tc.name      : create nonexist decoder
83  * @tc.desc      : function test
84  */
85 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0200, TestSize.Level1)
86 {
87     OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
88     ASSERT_EQ(nullptr, vdec_);
89 }
90 
91 /**
92  * @tc.number    : VIDEO_HWDEC_FUNCTION_0300
93  * @tc.name      : test h264 asyn decode buffer, pixel foramt nv12
94  * @tc.desc      : function test
95  */
96 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0300, TestSize.Level0)
97 {
98     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
99     vDecSample->INP_DIR = INP_DIR_1080_30;
100     vDecSample->DEFAULT_WIDTH = 1920;
101     vDecSample->DEFAULT_HEIGHT = 1080;
102     vDecSample->DEFAULT_FRAME_RATE = 30;
103     vDecSample->SF_OUTPUT = false;
104     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
105     vDecSample->WaitForEOS();
106     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
107 }
108 
109 /**
110  * @tc.number    : VIDEO_HWDEC_FUNCTION_0310
111  * @tc.name      : test h26 asyn decode buffer, pixel foramt nv21
112  * @tc.desc      : function test
113  */
114 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0310, TestSize.Level0)
115 {
116     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
117     vDecSample->INP_DIR = INP_DIR_1080_30;
118     vDecSample->DEFAULT_WIDTH = 1920;
119     vDecSample->DEFAULT_HEIGHT = 1080;
120     vDecSample->DEFAULT_FRAME_RATE = 30;
121     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
122     vDecSample->SF_OUTPUT = false;
123     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
124     vDecSample->WaitForEOS();
125     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
126 }
127 
128 /**
129  * @tc.number    : VIDEO_HWDEC_FUNCTION_0320
130  * @tc.name      : test h265 decode buffer, pixel foramt nv12
131  * @tc.desc      : function test
132  */
133 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0320, TestSize.Level0)
134 {
135     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
136     vDecSample->INP_DIR = INP_DIR_1080_30;
137     vDecSample->DEFAULT_WIDTH = 1920;
138     vDecSample->DEFAULT_HEIGHT = 1080;
139     vDecSample->DEFAULT_FRAME_RATE = 30;
140     vDecSample->SF_OUTPUT = false;
141     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
142     vDecSample->WaitForEOS();
143     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
144 }
145 
146 /**
147  * @tc.number    : VIDEO_HWDEC_FUNCTION_0330
148  * @tc.name      : test h265 decode buffer, pixel foramt nv21
149  * @tc.desc      : function test
150  */
151 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0330, TestSize.Level0)
152 {
153     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
154     vDecSample->INP_DIR = INP_DIR_1080_30;
155     vDecSample->DEFAULT_WIDTH = 1920;
156     vDecSample->DEFAULT_HEIGHT = 1080;
157     vDecSample->DEFAULT_FRAME_RATE = 30;
158     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
159     vDecSample->SF_OUTPUT = false;
160     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
161     vDecSample->WaitForEOS();
162     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
163 }
164 
165 /**
166  * @tc.number    : VIDEO_HWDEC_FUNCTION_0400
167  * @tc.name      : test h264 asyn decode surface, pixel foramt nv12
168  * @tc.desc      : function test
169  */
170 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0400, TestSize.Level0)
171 {
172     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
173     vDecSample->INP_DIR = INP_DIR_1080_30;
174     vDecSample->SF_OUTPUT = true;
175     vDecSample->DEFAULT_WIDTH = 1920;
176     vDecSample->DEFAULT_HEIGHT = 1080;
177     vDecSample->DEFAULT_FRAME_RATE = 30;
178     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
179     vDecSample->WaitForEOS();
180     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
181 }
182 
183 /**
184  * @tc.number    : VIDEO_HWDEC_FUNCTION_0410
185  * @tc.name      : test h264 asyn decode surface, pixel foramt nv21
186  * @tc.desc      : function test
187  */
188 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0410, TestSize.Level0)
189 {
190     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
191     vDecSample->INP_DIR = INP_DIR_1080_30;
192     vDecSample->SF_OUTPUT = true;
193     vDecSample->DEFAULT_WIDTH = 1920;
194     vDecSample->DEFAULT_HEIGHT = 1080;
195     vDecSample->DEFAULT_FRAME_RATE = 30;
196     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
197     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
198     vDecSample->WaitForEOS();
199     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
200 }
201 
202 /**
203  * @tc.number    : VIDEO_HWDEC_FUNCTION_0420
204  * @tc.name      : test h265 asyn decode surface, pixel foramt nv12
205  * @tc.desc      : function test
206  */
207 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0420, TestSize.Level0)
208 {
209     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
210     vDecSample->INP_DIR = INP_DIR_1080_30;
211     vDecSample->SF_OUTPUT = true;
212     vDecSample->DEFAULT_WIDTH = 1920;
213     vDecSample->DEFAULT_HEIGHT = 1080;
214     vDecSample->DEFAULT_FRAME_RATE = 30;
215     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
216     vDecSample->WaitForEOS();
217     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
218 }
219 
220 /**
221  * @tc.number    : VIDEO_HWDEC_FUNCTION_0430
222  * @tc.name      : test h265 asyn decode surface, pixel foramt nv21
223  * @tc.desc      : function test
224  */
225 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0430, TestSize.Level0)
226 {
227     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
228     vDecSample->INP_DIR = INP_DIR_1080_30;
229     vDecSample->SF_OUTPUT = true;
230     vDecSample->DEFAULT_WIDTH = 1920;
231     vDecSample->DEFAULT_HEIGHT = 1080;
232     vDecSample->DEFAULT_FRAME_RATE = 30;
233     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
234     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
235     vDecSample->WaitForEOS();
236     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
237 }
238 
239 /**
240  * @tc.number    : VIDEO_HWDEC_FUNCTION_0700
241  * @tc.name      : test set EOS when last frame
242  * @tc.desc      : function test
243  */
244 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0700, TestSize.Level1)
245 {
246     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
247     vDecSample->INP_DIR = INP_DIR_1080_30;
248     vDecSample->DEFAULT_WIDTH = 1920;
249     vDecSample->DEFAULT_HEIGHT = 1080;
250     vDecSample->DEFAULT_FRAME_RATE = 30;
251     vDecSample->SF_OUTPUT = false;
252     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
253     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
254     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
255     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
256     vDecSample->WaitForEOS();
257     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
258 }
259 
260 /**
261  * @tc.number    : VIDEO_HWDEC_FUNCTION_0800
262  * @tc.name      : test set EOS before last frame then stop
263  * @tc.desc      : function test
264  */
265 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0800, TestSize.Level1)
266 {
267     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
268     vDecSample->INP_DIR = INP_DIR_1080_30;
269     vDecSample->DEFAULT_WIDTH = 1920;
270     vDecSample->DEFAULT_HEIGHT = 1080;
271     vDecSample->DEFAULT_FRAME_RATE = 30;
272     vDecSample->SF_OUTPUT = false;
273     vDecSample->BEFORE_EOS_INPUT = true;
274     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
275     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
276     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
277     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
278     vDecSample->WaitForEOS();
279     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
280 }
281 
282 /**
283  * @tc.number    : VIDEO_HWDEC_FUNCTION_0900
284  * @tc.name      : test set EOS before last frame then input frames
285  * @tc.desc      : function test
286  */
287 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_0900, TestSize.Level1)
288 {
289     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
290     vDecSample->INP_DIR = INP_DIR_1080_30;
291     vDecSample->DEFAULT_WIDTH = 1920;
292     vDecSample->DEFAULT_HEIGHT = 1080;
293     vDecSample->DEFAULT_FRAME_RATE = 30;
294     vDecSample->SF_OUTPUT = false;
295     vDecSample->BEFORE_EOS_INPUT_INPUT = true;
296     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
297     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
298     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
299     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
300     vDecSample->WaitForEOS();
301     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
302 }
303 
304 /**
305  * @tc.number    : VIDEO_HWDEC_FUNCTION_1000
306  * @tc.name      : test reconfigure for new file with one decoder
307  * @tc.desc      : function test
308  */
309 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1000, TestSize.Level1)
310 {
311     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
312     vDecSample->INP_DIR = INP_DIR_1080_30;
313     vDecSample->DEFAULT_WIDTH = 1920;
314     vDecSample->DEFAULT_HEIGHT = 1080;
315     vDecSample->DEFAULT_FRAME_RATE = 30;
316     vDecSample->SF_OUTPUT = false;
317     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
318     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
319     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
320     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
321     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
322     vDecSample->WaitForEOS();
323     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
324     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
325     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
326     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
327     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
328     vDecSample->WaitForEOS();
329     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
330 }
331 
332 /**
333  * @tc.number    : VIDEO_HWDEC_FUNCTION_1100
334  * @tc.name      : test reconfigure for new file with the recreated decoder
335  * @tc.desc      : function test
336  */
337 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1100, TestSize.Level1)
338 {
339     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
340     vDecSample->INP_DIR = INP_DIR_1080_30;
341     vDecSample->DEFAULT_WIDTH = 1920;
342     vDecSample->DEFAULT_HEIGHT = 1080;
343     vDecSample->DEFAULT_FRAME_RATE = 30;
344     vDecSample->SF_OUTPUT = false;
345     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
346     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
347     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
348     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
349     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
350     vDecSample->WaitForEOS();
351     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
352     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
353     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
354     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
355     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
356     vDecSample->WaitForEOS();
357     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
358 }
359 
360 /**
361  * @tc.number    : VIDEO_HWDEC_FUNCTION_1200
362  * @tc.name      : repeat start and stop 5 times before EOS
363  * @tc.desc      : function test
364  */
365 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1200, TestSize.Level2)
366 {
367     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
368     vDecSample->INP_DIR = INP_DIR_1080_30;
369     vDecSample->DEFAULT_WIDTH = 1920;
370     vDecSample->DEFAULT_HEIGHT = 1080;
371     vDecSample->DEFAULT_FRAME_RATE = 30;
372     vDecSample->SF_OUTPUT = false;
373     vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
374     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
375     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
376     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
377     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
378     vDecSample->WaitForEOS();
379     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
380 }
381 
382 /**
383  * @tc.number    : VIDEO_HWDEC_FUNCTION_1300
384  * @tc.name      : repeat start and flush 5 times before EOS
385  * @tc.desc      : function test
386  */
387 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1300, TestSize.Level2)
388 {
389     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
390     vDecSample->INP_DIR = INP_DIR_1080_30;
391     vDecSample->DEFAULT_WIDTH = 1920;
392     vDecSample->DEFAULT_HEIGHT = 1080;
393     vDecSample->DEFAULT_FRAME_RATE = 30;
394     vDecSample->SF_OUTPUT = false;
395     vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
396     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
397     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
398     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
399     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
400     vDecSample->WaitForEOS();
401     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
402 }
403 
404 /**
405  * @tc.number    : VIDEO_HWDEC_FUNCTION_1400
406  * @tc.name      : set larger width and height
407  * @tc.desc      : function test
408  */
409 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1400, TestSize.Level2)
410 {
411     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
412     vDecSample->INP_DIR = INP_DIR_720_30;
413     vDecSample->DEFAULT_WIDTH = 1920;
414     vDecSample->DEFAULT_HEIGHT = 1080;
415     vDecSample->DEFAULT_FRAME_RATE = 30;
416     vDecSample->SF_OUTPUT = false;
417     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
418     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
419     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
420     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
421     vDecSample->WaitForEOS();
422     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
423 }
424 
425 /**
426  * @tc.number    : VIDEO_HWDEC_FUNCTION_1600
427  * @tc.name      : 265 decode
428  * @tc.desc      : function test
429  */
430 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1600, TestSize.Level2)
431 {
432     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
433     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
434     vDecSample->DEFAULT_WIDTH = 1920;
435     vDecSample->DEFAULT_HEIGHT = 1080;
436     vDecSample->DEFAULT_FRAME_RATE = 30;
437     vDecSample->SF_OUTPUT = false;
438     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
439     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
440     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
441     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
442     vDecSample->WaitForEOS();
443     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
444 }
445 
446 /**
447  * @tc.number    : VIDEO_HWDEC_FUNCTION_1700
448  * @tc.name      : resolution change
449  * @tc.desc      : function test
450  */
451 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_1700, TestSize.Level2)
452 {
453     if (g_codecName.find("hisi") != string::npos) {
454         auto vDecSample = make_shared<VDecNdkSample>();
455         vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
456         vDecSample->DEFAULT_WIDTH = 1104;
457         vDecSample->DEFAULT_HEIGHT = 622;
458         vDecSample->DEFAULT_FRAME_RATE = 30;
459         vDecSample->SF_OUTPUT = false;
460         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
461         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
462         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
463         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
464         vDecSample->WaitForEOS();
465         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
466     } else {
467         cout << "hardware encoder is rk,skip." << endl;
468     }
469 }
470 /**
471  * @tc.number    : SURF_CHANGE_FUNC_001
472  * @tc.name      : surf change in normal state
473  * @tc.desc      : function test
474  */
475 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)
476 {
477     auto vDecSample = make_shared<VDecNdkSample>();
478     vDecSample->INP_DIR = INP_DIR_1080_30;
479     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
480     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
481     vDecSample->DEFAULT_FRAME_RATE = 30;
482     vDecSample->SF_OUTPUT = true;
483     vDecSample->autoSwitchSurface = true;
484     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
485     vDecSample->sleepOnFPS = true;
486     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
487     vDecSample->WaitForEOS();
488     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
489     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
490     ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
491     ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
492 }
493 /**
494  * @tc.number    : SURF_CHANGE_FUNC_002
495  * @tc.name      : surf change in flushed state
496  * @tc.desc      : function test
497  */
498 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)
499 {
500     auto vDecSample = make_shared<VDecNdkSample>();
501     vDecSample->INP_DIR = INP_DIR_1080_30;
502     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
503     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
504     vDecSample->DEFAULT_FRAME_RATE = 30;
505     vDecSample->SF_OUTPUT = true;
506     vDecSample->autoSwitchSurface = true;
507     vDecSample->sleepOnFPS = true;
508     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
509     ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
510     ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
511     ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
512     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
513 }
514 /**
515  * @tc.number    : SURF_CHANGE_FUNC_003
516  * @tc.name      : surf change in buffer mode
517  * @tc.desc      : function test
518  */
519 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)
520 {
521     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
522     vDecSample->INP_DIR = INP_DIR_1080_30;
523     vDecSample->DEFAULT_WIDTH = 1920;
524     vDecSample->DEFAULT_HEIGHT = 1080;
525     vDecSample->DEFAULT_FRAME_RATE = 30;
526     vDecSample->SF_OUTPUT = false;
527     vDecSample->CreateSurface();
528     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
529     ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
530     vDecSample->WaitForEOS();
531     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
532 }
533 /**
534  * @tc.number    : SURF_CHANGE_FUNC_004
535  * @tc.name      : repeat call setSurface fastly
536  * @tc.desc      : function test
537  */
538 HWTEST_F(HwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)
539 {
540     auto vDecSample = make_shared<VDecNdkSample>();
541     vDecSample->INP_DIR = INP_DIR_1080_30;
542     vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
543     vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
544     vDecSample->DEFAULT_FRAME_RATE = 30;
545     vDecSample->SF_OUTPUT = true;
546     vDecSample->autoSwitchSurface = true;
547     vDecSample->sleepOnFPS = true;
548     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
549     ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
550     vDecSample->WaitForEOS();
551 }
552 
553 /**
554  * @tc.number    : OUTPUT_DECS_FUNC_001
555  * @tc.name      : get decode output descriptions h264
556  * @tc.desc      : function test
557  */
558 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_001, TestSize.Level0)
559 {
560     if (g_codecName.find("hisi") != string::npos) {
561         auto vDecSample = make_shared<VDecNdkSample>();
562         vDecSample->INP_DIR = "/data/test/media/1920x1080.h264";
563         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
564         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
565         vDecSample->DEFAULT_FRAME_RATE = 30;
566         vDecSample->needCheckOutputDesc = true;
567         vDecSample->expectCropTop = 0;
568         vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
569         vDecSample->expectCropLeft = 0;
570         vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
571 
572         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
573         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
574         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
575         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
576         vDecSample->WaitForEOS();
577         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
578     } else {
579         cout << "hardware encoder is rk,skip." << endl;
580     }
581 }
582 /**
583  * @tc.number    : OUTPUT_DECS_FUNC_002
584  * @tc.name      : get decode output descriptions h265
585  * @tc.desc      : function test
586  */
587 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_002, TestSize.Level0)
588 {
589     if (g_codecName.find("hisi") != string::npos) {
590         auto vDecSample = make_shared<VDecNdkSample>();
591         vDecSample->INP_DIR = "/data/test/media/1920x1080.h265";
592         vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
593         vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
594         vDecSample->DEFAULT_FRAME_RATE = 30;
595         vDecSample->needCheckOutputDesc = true;
596         vDecSample->expectCropTop = 0;
597         vDecSample->expectCropBottom = DEFAULT_HEIGHT - 1;
598         vDecSample->expectCropLeft = 0;
599         vDecSample->expectCropRight = DEFAULT_WIDTH - 1;
600 
601         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
602         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
603         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
604         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
605         vDecSample->WaitForEOS();
606         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
607     } else {
608         cout << "hardware encoder is rk,skip." << endl;
609     }
610 }
611 /**
612  * @tc.number    : OUTPUT_DECS_FUNC_003
613  * @tc.name      : get decode output descriptions h264 ,4k
614  * @tc.desc      : function test
615  */
616 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_003, TestSize.Level0)
617 {
618     if (g_codecName.find("hisi") != string::npos) {
619         auto vDecSample = make_shared<VDecNdkSample>();
620         vDecSample->INP_DIR = "/data/test/media/3840x2160.h264";
621         vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
622         vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
623         vDecSample->DEFAULT_FRAME_RATE = 30;
624         vDecSample->needCheckOutputDesc = true;
625         vDecSample->expectCropTop = 0;
626         vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
627         vDecSample->expectCropLeft = 0;
628         vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
629 
630         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
631         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
632         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
633         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
634         vDecSample->WaitForEOS();
635         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
636     } else {
637         cout << "hardware encoder is rk,skip." << endl;
638     }
639 }
640 /**
641  * @tc.number    : OUTPUT_DECS_FUNC_004
642  * @tc.name      : get decode output descriptions h265 ,4k
643  * @tc.desc      : function test
644  */
645 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_004, TestSize.Level0)
646 {
647     if (g_codecName.find("hisi") != string::npos) {
648         auto vDecSample = make_shared<VDecNdkSample>();
649         vDecSample->INP_DIR = "/data/test/media/3840x2160.h265";
650         vDecSample->DEFAULT_WIDTH = UHD_RESOLUTION[0];
651         vDecSample->DEFAULT_HEIGHT = UHD_RESOLUTION[1];
652         vDecSample->DEFAULT_FRAME_RATE = 30;
653         vDecSample->needCheckOutputDesc = true;
654         vDecSample->expectCropTop = 0;
655         vDecSample->expectCropBottom = UHD_RESOLUTION[1] - 1;
656         vDecSample->expectCropLeft = 0;
657         vDecSample->expectCropRight = UHD_RESOLUTION[0] - 1;
658 
659         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
660         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
661         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
662         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
663         vDecSample->WaitForEOS();
664         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
665     } else {
666         cout << "hardware encoder is rk,skip." << endl;
667     }
668 }
669 /**
670  * @tc.number    : OUTPUT_DECS_FUNC_005
671  * @tc.name      : get decode output descriptions h264 ,crop size
672  * @tc.desc      : function test
673  */
674 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_005, TestSize.Level0)
675 {
676     if (g_codecName.find("hisi") != string::npos) {
677         auto vDecSample = make_shared<VDecNdkSample>();
678         vDecSample->INP_DIR = "/data/test/media/1104x622.h264";
679         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
680         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
681         vDecSample->DEFAULT_FRAME_RATE = 30;
682         vDecSample->needCheckOutputDesc = true;
683         vDecSample->expectCropTop = 0;
684         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
685         vDecSample->expectCropLeft = 0;
686         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
687 
688         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
689         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
690         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
691         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
692         vDecSample->WaitForEOS();
693         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
694     } else {
695         cout << "hardware encoder is rk,skip." << endl;
696     }
697 }
698 /**
699  * @tc.number    : OUTPUT_DECS_FUNC_006
700  * @tc.name      : get decode output descriptions h265 ,crop size
701  * @tc.desc      : function test
702  */
703 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_006, TestSize.Level0)
704 {
705     if (g_codecName.find("hisi") != string::npos) {
706         auto vDecSample = make_shared<VDecNdkSample>();
707         vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
708         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
709         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
710         vDecSample->DEFAULT_FRAME_RATE = 30;
711         vDecSample->needCheckOutputDesc = true;
712         vDecSample->expectCropTop = 0;
713         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
714         vDecSample->expectCropLeft = 0;
715         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
716 
717         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHEVC));
718         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
719         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
720         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
721         vDecSample->WaitForEOS();
722         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
723     } else {
724         cout << "hardware encoder is rk,skip." << endl;
725     }
726 }
727 /**
728  * @tc.number    : OUTPUT_DECS_FUNC_007
729  * @tc.name      : get decode output descriptions h265 ,resolution change
730  * @tc.desc      : function test
731  */
732 HWTEST_F(HwdecFuncNdkTest, OUTPUT_DECS_FUNC_007, TestSize.Level0)
733 {
734     if (g_codecName.find("hisi") != string::npos) {
735         auto vDecSample = make_shared<VDecNdkSample>();
736         vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
737         vDecSample->DEFAULT_WIDTH = HD_RESOLUTION[0];
738         vDecSample->DEFAULT_HEIGHT = HD_RESOLUTION[1];
739         vDecSample->DEFAULT_FRAME_RATE = 30;
740         vDecSample->isResChangeStream = true;
741         vDecSample->expectCropTop = 0;
742         vDecSample->expectCropBottom = HD_RESOLUTION[1] - 1;
743         vDecSample->expectCropLeft = 0;
744         vDecSample->expectCropRight = HD_RESOLUTION[0] - 1;
745 
746         ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
747         ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
748         ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
749         ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
750         vDecSample->WaitForEOS();
751         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
752     } else {
753         cout << "hardware encoder is rk,skip." << endl;
754     }
755 }
756 
757 /**
758  * @tc.number    : MAX_INPUT_SIZE_CHECK_001
759  * @tc.name      : MaxInputSize value incorrect
760  * @tc.desc      : function test
761  */
762 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)
763 {
764     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
765     vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
766     vDecSample->DEFAULT_WIDTH = 1920;
767     vDecSample->DEFAULT_HEIGHT = 1080;
768     vDecSample->DEFAULT_FRAME_RATE = 30;
769     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
770     vDecSample->maxInputSize = -1;
771     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
772     vDecSample->WaitForEOS();
773     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
774 }
775 
776 /**
777  * @tc.number    : MAX_INPUT_SIZE_CHECK_002
778  * @tc.name      : MaxInputSize value incorrect
779  * @tc.desc      : function test
780  */
781 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)
782 {
783     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
784     vDecSample->INP_DIR = "/data/test/media/1920_1080_10_30Mb.h264";
785     vDecSample->DEFAULT_WIDTH = 1920;
786     vDecSample->DEFAULT_HEIGHT = 1080;
787     vDecSample->DEFAULT_FRAME_RATE = 30;
788     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
789     vDecSample->maxInputSize = INT_MAX;
790     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
791     vDecSample->WaitForEOS();
792     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
793 }
794 
795 /**
796  * @tc.number    : MAX_INPUT_SIZE_CHECK_003
797  * @tc.name      : MaxInputSize value normal
798  * @tc.desc      : function test
799  */
800 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_003, TestSize.Level0)
801 {
802     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
803     vDecSample->INP_DIR = "/data/test/media/1104x622.h264";
804     vDecSample->DEFAULT_WIDTH = 1108;
805     vDecSample->DEFAULT_HEIGHT = 622;
806     vDecSample->DEFAULT_FRAME_RATE = 30;
807     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
808     vDecSample->maxInputSize = MAX_NALU_LEN;
809     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecName));
810     vDecSample->WaitForEOS();
811     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
812 }
813 /**
814  * @tc.number    : MAX_INPUT_SIZE_CHECK_004
815  * @tc.name      : MaxInputSize value incorrect hevc
816  * @tc.desc      : function test
817  */
818 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_004, TestSize.Level0)
819 {
820     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
821     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
822     vDecSample->DEFAULT_WIDTH = 1920;
823     vDecSample->DEFAULT_HEIGHT = 1080;
824     vDecSample->DEFAULT_FRAME_RATE = 30;
825     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
826     vDecSample->maxInputSize = -1;
827     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
828     vDecSample->WaitForEOS();
829     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
830 }
831 
832 /**
833  * @tc.number    : MAX_INPUT_SIZE_CHECK_005
834  * @tc.name      : MaxInputSize value incorrect
835  * @tc.desc      : function test
836  */
837 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_005, TestSize.Level0)
838 {
839     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
840     vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
841     vDecSample->DEFAULT_WIDTH = 1920;
842     vDecSample->DEFAULT_HEIGHT = 1080;
843     vDecSample->DEFAULT_FRAME_RATE = 30;
844     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
845     vDecSample->maxInputSize = INT_MAX;
846     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
847     vDecSample->WaitForEOS();
848     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
849 }
850 
851 /**
852  * @tc.number    : MAX_INPUT_SIZE_CHECK_006
853  * @tc.name      : MaxInputSize value normal
854  * @tc.desc      : function test
855  */
856 HWTEST_F(HwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_006, TestSize.Level0)
857 {
858     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
859     vDecSample->INP_DIR = "/data/test/media/1104x622.h265";
860     vDecSample->DEFAULT_WIDTH = 1108;
861     vDecSample->DEFAULT_HEIGHT = 622;
862     vDecSample->DEFAULT_FRAME_RATE = 30;
863     vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
864     vDecSample->maxInputSize = MAX_NALU_LEN;
865     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHEVC));
866     vDecSample->WaitForEOS();
867     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
868 }
869 
870 /**
871  * @tc.number    : FLUSH_CHECK_001
872  * @tc.name      : Compare the flush frame with the normal process frame
873  * @tc.desc      : function test
874  */
875 HWTEST_F(HwdecFuncNdkTest, FLUSH_CHECK_001, TestSize.Level0)
876 {
877     shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
878     vDecSample->INP_DIR = INP_DIR_1080_30;
879     vDecSample->DEFAULT_WIDTH = 1920;
880     vDecSample->DEFAULT_HEIGHT = 1080;
881     vDecSample->DEFAULT_FRAME_RATE = 30;
882     vDecSample->SF_OUTPUT = false;
883     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecName));
884     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
885     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
886     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
887     vDecSample->WaitForEOS();
888     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
889     cout << "--vDecSample--" << vDecSample->outCount << endl;
890     shared_ptr<VDecNdkSample> vDecSample1 = make_shared<VDecNdkSample>();
891     vDecSample1->INP_DIR = INP_DIR_1080_30;
892     vDecSample1->DEFAULT_WIDTH = 1920;
893     vDecSample1->DEFAULT_HEIGHT = 1080;
894     vDecSample1->DEFAULT_FRAME_RATE = 30;
895     vDecSample1->SF_OUTPUT = false;
896     vDecSample1->REPEAT_START_FLUSH_BEFORE_EOS = 1;
897     ASSERT_EQ(AV_ERR_OK, vDecSample1->CreateVideoDecoder(g_codecName));
898     ASSERT_EQ(AV_ERR_OK, vDecSample1->ConfigureVideoDecoder());
899     ASSERT_EQ(AV_ERR_OK, vDecSample1->SetVideoDecoderCallback());
900     ASSERT_EQ(AV_ERR_OK, vDecSample1->StartVideoDecoder());
901     vDecSample1->WaitForEOS();
902     ASSERT_EQ(AV_ERR_OK, vDecSample1->errCount);
903     cout << "--Flush--" << vDecSample1->outCount << endl;
904     ASSERT_EQ(vDecSample->outCount, vDecSample1->outCount);
905 }
906 
907 /**
908  * @tc.number    : VIDEO_HWDEC_FUNCTION_ATTIME_0010
909  * @tc.name      : test h264 asyn decode surface,use at time
910  * @tc.desc      : function test
911  */
912 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0010, TestSize.Level0)
913 {
914     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
915     vDecSample->INP_DIR = INP_DIR_720_30;
916     vDecSample->SF_OUTPUT = true;
917     vDecSample->DEFAULT_WIDTH = 1280;
918     vDecSample->DEFAULT_HEIGHT = 720;
919     vDecSample->DEFAULT_FRAME_RATE = 30;
920     vDecSample->rsAtTime = true;
921     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecName));
922     vDecSample->WaitForEOS();
923     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
924 }
925 
926 /**
927  * @tc.number    : VIDEO_HWDEC_FUNCTION_ATTIME_0011
928  * @tc.name      : test h265 asyn decode surface,use at time
929  * @tc.desc      : function test
930  */
931 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0011, TestSize.Level1)
932 {
933     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
934     vDecSample->INP_DIR = INP_DIR_1080_20;
935     vDecSample->SF_OUTPUT = true;
936     vDecSample->DEFAULT_WIDTH = 1920;
937     vDecSample->DEFAULT_HEIGHT = 1080;
938     vDecSample->DEFAULT_FRAME_RATE = 30;
939     vDecSample->rsAtTime = true;
940     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
941     vDecSample->WaitForEOS();
942     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
943 }
944 
945 /**
946  * @tc.number    : VIDEO_HWDEC_FUNCTION_ATTIME_0012
947  * @tc.name      : test h265 10bit asyn decode surface,use at time
948  * @tc.desc      : function test
949  */
950 HWTEST_F(HwdecFuncNdkTest, VIDEO_HWDEC_FUNCTION_ATTIME_0012, TestSize.Level1)
951 {
952     shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
953     vDecSample->DEFAULT_PROFILE = HEVC_PROFILE_MAIN;
954     vDecSample->INP_DIR = inpDirVivid;
955     vDecSample->SF_OUTPUT = true;
956     vDecSample->DEFAULT_WIDTH = 3840;
957     vDecSample->DEFAULT_HEIGHT = 2160;
958     vDecSample->DEFAULT_FRAME_RATE = 30;
959     vDecSample->rsAtTime = true;
960     vDecSample->useHDRSource = true;
961     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
962     vDecSample->WaitForEOS();
963     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
964 }
965 } // namespace