• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2025 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 #include "native_avformat.h"
25 #include "openssl/sha.h"
26 
27 #ifdef SUPPORT_DRM
28 #include "native_mediakeysession.h"
29 #include "native_mediakeysystem.h"
30 #endif
31 
32 #define MAX_THREAD 16
33 
34 using namespace std;
35 using namespace OHOS;
36 using namespace OHOS::Media;
37 using namespace testing::ext;
38 
39 namespace OHOS {
40 namespace Media {
41 class Mpeg4SwdecFuncNdkTest : public testing::Test {
42 public:
43     static void SetUpTestCase();
44     static void TearDownTestCase();
45     void SetUp() override;
46     void TearDown() override;
47     void InputFunc();
48     void OutputFunc();
49     void Release();
50     int32_t Stop();
51 
52 protected:
53     const char *INP_DIR_720_30 = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
54     const char *INP_DIR_1080_30 = "/data/test/media/mpeg4_main@level4_1920x1080_30.m4v";
55 };
56 } // namespace Media
57 } // namespace OHOS
58 
59 namespace {
60 static OH_AVCapability *cap_mpeg4 = nullptr;
61 static string g_codecNameMpeg4 = "";
62 } // namespace
63 
SetUpTestCase()64 void Mpeg4SwdecFuncNdkTest::SetUpTestCase()
65 {
66     cap_mpeg4 = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG4_PART2, false, SOFTWARE);
67     g_codecNameMpeg4 = OH_AVCapability_GetName(cap_mpeg4);
68     cout << "g_codecNameMpeg4: " << g_codecNameMpeg4 << endl;
69 }
70 
TearDownTestCase()71 void Mpeg4SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()72 void Mpeg4SwdecFuncNdkTest::SetUp() {}
TearDown()73 void Mpeg4SwdecFuncNdkTest::TearDown() {}
74 
75 namespace {
76 /**
77  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0100
78  * @tc.name      : decode mpeg4 stream, buffer mode, output pixel format is nv12
79  * @tc.desc      : function test
80  */
81 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0100, TestSize.Level2)
82 {
83     auto vDecSample = make_shared<VDecNdkSample>();
84     vDecSample->INP_DIR = INP_DIR_1080_30;
85     vDecSample->DEFAULT_WIDTH = 1920;
86     vDecSample->DEFAULT_HEIGHT = 1080;
87     vDecSample->DEFAULT_FRAME_RATE = 30;
88     vDecSample->SURFACE_OUTPUT = false;
89     vDecSample->checkOutPut = true;
90     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
91     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
92     vDecSample->WaitForEOS();
93     ASSERT_EQ(0, vDecSample->errCount);
94 }
95 
96 /**
97  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0200
98  * @tc.name      : decode mpeg4 stream, buffer mode, output pixel format is nv21
99  * @tc.desc      : function test
100  */
101 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0200, TestSize.Level2)
102 {
103     auto vDecSample = make_shared<VDecNdkSample>();
104     vDecSample->INP_DIR = INP_DIR_1080_30;
105     vDecSample->DEFAULT_WIDTH = 1920;
106     vDecSample->DEFAULT_HEIGHT = 1080;
107     vDecSample->DEFAULT_FRAME_RATE = 30;
108     vDecSample->SURFACE_OUTPUT = false;
109     vDecSample->checkOutPut = true;
110     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
111     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
112     vDecSample->WaitForEOS();
113     ASSERT_EQ(0, vDecSample->errCount);
114 }
115 
116 /**
117  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0300
118  * @tc.name      : decode mpeg4 stream, buffer mode, output pixel format is YUVI420
119  * @tc.desc      : function test
120  */
121 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0300, TestSize.Level2)
122 {
123     auto 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->SURFACE_OUTPUT = false;
129     vDecSample->checkOutPut = true;
130     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
131     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
132     vDecSample->WaitForEOS();
133     ASSERT_EQ(0, vDecSample->errCount);
134 }
135 
136 /**
137  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0400
138  * @tc.name      : decode mpeg4 stream, buffer mode, output pixel format is RGBA
139  * @tc.desc      : function test
140  */
141 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0400, TestSize.Level2)
142 {
143     auto vDecSample = make_shared<VDecNdkSample>();
144     vDecSample->INP_DIR = INP_DIR_1080_30;
145     vDecSample->DEFAULT_WIDTH = 1920;
146     vDecSample->DEFAULT_HEIGHT = 1080;
147     vDecSample->DEFAULT_FRAME_RATE = 30;
148     vDecSample->SURFACE_OUTPUT = false;
149     vDecSample->checkOutPut = false;
150     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
151     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
152     vDecSample->WaitForEOS();
153     ASSERT_EQ(0, vDecSample->errCount);
154 }
155 
156 /**
157  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0500
158  * @tc.name      : decode mpeg4 stream, surface mode, output pixel format is NV12
159  * @tc.desc      : function test
160  */
161 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0500, TestSize.Level2)
162 {
163     auto vDecSample = make_shared<VDecNdkSample>();
164     vDecSample->INP_DIR = INP_DIR_1080_30;
165     vDecSample->DEFAULT_WIDTH = 1920;
166     vDecSample->DEFAULT_HEIGHT = 1080;
167     vDecSample->DEFAULT_FRAME_RATE = 30;
168     vDecSample->SURFACE_OUTPUT = true;
169     vDecSample->checkOutPut = true;
170     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
171     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
172     vDecSample->WaitForEOS();
173     ASSERT_EQ(0, vDecSample->errCount);
174 }
175 
176 /**
177  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0600
178  * @tc.name      : decode mpeg4 stream, surface mode, output pixel format is NV21
179  * @tc.desc      : function test
180  */
181 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0600, TestSize.Level2)
182 {
183     auto vDecSample = make_shared<VDecNdkSample>();
184     vDecSample->INP_DIR = INP_DIR_1080_30;
185     vDecSample->DEFAULT_WIDTH = 1920;
186     vDecSample->DEFAULT_HEIGHT = 1080;
187     vDecSample->DEFAULT_FRAME_RATE = 30;
188     vDecSample->SURFACE_OUTPUT = true;
189     vDecSample->checkOutPut = true;
190     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
191     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
192     vDecSample->WaitForEOS();
193     ASSERT_EQ(0, vDecSample->errCount);
194 }
195 
196 /**
197  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0700
198  * @tc.name      : decode mpeg4 stream, surface mode, output pixel format is YUVI420
199  * @tc.desc      : function test
200  */
201 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0700, TestSize.Level2)
202 {
203     auto vDecSample = make_shared<VDecNdkSample>();
204     vDecSample->INP_DIR = INP_DIR_1080_30;
205     vDecSample->DEFAULT_WIDTH = 1920;
206     vDecSample->DEFAULT_HEIGHT = 1080;
207     vDecSample->DEFAULT_FRAME_RATE = 30;
208     vDecSample->SURFACE_OUTPUT = true;
209     vDecSample->checkOutPut = true;
210     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
211     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
212     vDecSample->WaitForEOS();
213     ASSERT_EQ(0, vDecSample->errCount);
214 }
215 
216 /**
217  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0800
218  * @tc.name      : decode mpeg4 stream, surface mode, output pixel format is RGBA
219  * @tc.desc      : function test
220  */
221 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0800, TestSize.Level2)
222 {
223     auto vDecSample = make_shared<VDecNdkSample>();
224     vDecSample->INP_DIR = INP_DIR_1080_30;
225     vDecSample->DEFAULT_WIDTH = 1920;
226     vDecSample->DEFAULT_HEIGHT = 1080;
227     vDecSample->DEFAULT_FRAME_RATE = 30;
228     vDecSample->SURFACE_OUTPUT = true;
229     vDecSample->checkOutPut = false;
230     vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
231     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
232     vDecSample->WaitForEOS();
233     ASSERT_EQ(0, vDecSample->errCount);
234 }
235 
236 /**
237  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_0900
238  * @tc.name      : software decode frame
239  * @tc.desc      : function test
240  */
241 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0900, TestSize.Level0)
242 {
243     VDecNdkSample *vDecSample = new VDecNdkSample();
244 
245     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
246     ASSERT_EQ(AV_ERR_OK, ret);
247     ret = vDecSample->SetVideoDecoderCallback();
248     ASSERT_EQ(AV_ERR_OK, ret);
249     ret = vDecSample->ConfigureVideoDecoder();
250     ASSERT_EQ(AV_ERR_OK, ret);
251     vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
252     ret = vDecSample->StartVideoDecoder();
253     ASSERT_EQ(AV_ERR_OK, ret);
254     vDecSample->WaitForEOS();
255     ASSERT_EQ(0, vDecSample->errCount);
256 }
257 
258 /**
259  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1000
260  * @tc.name      : software decode frame
261  * @tc.desc      : function test
262  */
263 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1000, TestSize.Level2)
264 {
265     VDecNdkSample *vDecSample = new VDecNdkSample();
266 
267     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
268     ASSERT_EQ(AV_ERR_OK, ret);
269     ret = vDecSample->SetVideoDecoderCallback();
270     ASSERT_EQ(AV_ERR_OK, ret);
271     ret = vDecSample->ConfigureVideoDecoder();
272     ASSERT_EQ(AV_ERR_OK, ret);
273     vDecSample->INP_DIR = "/data/test/media/mpeg4_simple_scalable@level2_352x288_60.m4v";
274     ret = vDecSample->StartVideoDecoder();
275     ASSERT_EQ(AV_ERR_OK, ret);
276     vDecSample->WaitForEOS();
277     ASSERT_EQ(0, vDecSample->errCount);
278 }
279 
280 /**
281  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1100
282  * @tc.name      : software decode frame
283  * @tc.desc      : function test
284  */
285 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1100, TestSize.Level2)
286 {
287     VDecNdkSample *vDecSample = new VDecNdkSample();
288 
289     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
290     ASSERT_EQ(AV_ERR_OK, ret);
291     ret = vDecSample->SetVideoDecoderCallback();
292     ASSERT_EQ(AV_ERR_OK, ret);
293     ret = vDecSample->ConfigureVideoDecoder();
294     ASSERT_EQ(AV_ERR_OK, ret);
295     vDecSample->INP_DIR = "/data/test/media/mpeg4_core@level1_176x144_30.m4v";
296     ret = vDecSample->StartVideoDecoder();
297     ASSERT_EQ(AV_ERR_OK, ret);
298     vDecSample->WaitForEOS();
299     ASSERT_EQ(0, vDecSample->errCount);
300 }
301 
302 /**
303  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1200
304  * @tc.name      : software decode frame
305  * @tc.desc      : function test
306  */
307 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1200, TestSize.Level0)
308 {
309     VDecNdkSample *vDecSample = new VDecNdkSample();
310 
311     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
312     ASSERT_EQ(AV_ERR_OK, ret);
313     ret = vDecSample->SetVideoDecoderCallback();
314     ASSERT_EQ(AV_ERR_OK, ret);
315     ret = vDecSample->ConfigureVideoDecoder();
316     ASSERT_EQ(AV_ERR_OK, ret);
317     vDecSample->INP_DIR = "/data/test/media/mpeg4_main@level4_1920x1080_30.m4v";
318     ret = vDecSample->StartVideoDecoder();
319     ASSERT_EQ(AV_ERR_OK, ret);
320     vDecSample->WaitForEOS();
321     ASSERT_EQ(0, vDecSample->errCount);
322 }
323 
324 /**
325  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1300
326  * @tc.name      : software decode frame
327  * @tc.desc      : function test
328  */
329 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1300, TestSize.Level2)
330 {
331     VDecNdkSample *vDecSample = new VDecNdkSample();
332 
333     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
334     ASSERT_EQ(AV_ERR_OK, ret);
335     ret = vDecSample->SetVideoDecoderCallback();
336     ASSERT_EQ(AV_ERR_OK, ret);
337     ret = vDecSample->ConfigureVideoDecoder();
338     ASSERT_EQ(AV_ERR_OK, ret);
339     vDecSample->INP_DIR = "/data/test/media/mpeg4_N_bit@level2_640x480_60.m4v";
340     ret = vDecSample->StartVideoDecoder();
341     ASSERT_EQ(AV_ERR_OK, ret);
342     vDecSample->WaitForEOS();
343     ASSERT_EQ(0, vDecSample->errCount);
344 }
345 
346 /**
347  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1400
348  * @tc.name      : software decode frame
349  * @tc.desc      : function test
350  */
351 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1400, TestSize.Level2)
352 {
353     VDecNdkSample *vDecSample = new VDecNdkSample();
354 
355     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
356     ASSERT_EQ(AV_ERR_OK, ret);
357     ret = vDecSample->SetVideoDecoderCallback();
358     ASSERT_EQ(AV_ERR_OK, ret);
359     ret = vDecSample->ConfigureVideoDecoder();
360     ASSERT_EQ(AV_ERR_OK, ret);
361     vDecSample->INP_DIR = "/data/test/media/mpeg4_Hybrid@level2_720x480_30.m4v";
362     ret = vDecSample->StartVideoDecoder();
363     ASSERT_EQ(AV_ERR_OK, ret);
364     vDecSample->WaitForEOS();
365     ASSERT_EQ(0, vDecSample->errCount);
366 }
367 
368 /**
369  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1500
370  * @tc.name      : software decode frame
371  * @tc.desc      : function test
372  */
373 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1500, TestSize.Level2)
374 {
375     VDecNdkSample *vDecSample = new VDecNdkSample();
376 
377     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
378     ASSERT_EQ(AV_ERR_OK, ret);
379     ret = vDecSample->SetVideoDecoderCallback();
380     ASSERT_EQ(AV_ERR_OK, ret);
381     ret = vDecSample->ConfigureVideoDecoder();
382     ASSERT_EQ(AV_ERR_OK, ret);
383     vDecSample->INP_DIR = "/data/test/media/mpeg4_Basic_Animated_Texture@level2_720x576_30.m4v";
384     ret = vDecSample->StartVideoDecoder();
385     ASSERT_EQ(AV_ERR_OK, ret);
386     vDecSample->WaitForEOS();
387     ASSERT_EQ(0, vDecSample->errCount);
388 }
389 
390 /**
391  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1600
392  * @tc.name      : software decode frame
393  * @tc.desc      : function test
394  */
395 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1600, TestSize.Level2)
396 {
397     VDecNdkSample *vDecSample = new VDecNdkSample();
398 
399     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
400     ASSERT_EQ(AV_ERR_OK, ret);
401     ret = vDecSample->SetVideoDecoderCallback();
402     ASSERT_EQ(AV_ERR_OK, ret);
403     ret = vDecSample->ConfigureVideoDecoder();
404     ASSERT_EQ(AV_ERR_OK, ret);
405     vDecSample->INP_DIR = "/data/test/media/mpeg4_Scalable_Texture@level1_1600x900_60.m4v";
406     ret = vDecSample->StartVideoDecoder();
407     ASSERT_EQ(AV_ERR_OK, ret);
408     vDecSample->WaitForEOS();
409     ASSERT_EQ(0, vDecSample->errCount);
410 }
411 
412 /**
413  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1700
414  * @tc.name      : software decode frame
415  * @tc.desc      : function test
416  */
417 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1700, TestSize.Level0)
418 {
419     VDecNdkSample *vDecSample = new VDecNdkSample();
420 
421     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
422     ASSERT_EQ(AV_ERR_OK, ret);
423     ret = vDecSample->SetVideoDecoderCallback();
424     ASSERT_EQ(AV_ERR_OK, ret);
425     ret = vDecSample->ConfigureVideoDecoder();
426     ASSERT_EQ(AV_ERR_OK, ret);
427     vDecSample->INP_DIR = "/data/test/media/mpeg4_Simple_FA@level2_1024x768_30.m4v";
428     ret = vDecSample->StartVideoDecoder();
429     ASSERT_EQ(AV_ERR_OK, ret);
430     vDecSample->WaitForEOS();
431     ASSERT_EQ(0, vDecSample->errCount);
432 }
433 
434 /**
435  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1800
436  * @tc.name      : software decode frame
437  * @tc.desc      : function test
438  */
439 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1800, TestSize.Level2)
440 {
441     VDecNdkSample *vDecSample = new VDecNdkSample();
442 
443     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
444     ASSERT_EQ(AV_ERR_OK, ret);
445     ret = vDecSample->SetVideoDecoderCallback();
446     ASSERT_EQ(AV_ERR_OK, ret);
447     ret = vDecSample->ConfigureVideoDecoder();
448     ASSERT_EQ(AV_ERR_OK, ret);
449     vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Real_Time_Simple@level4_1440x1080_60.m4v";
450     ret = vDecSample->StartVideoDecoder();
451     ASSERT_EQ(AV_ERR_OK, ret);
452     vDecSample->WaitForEOS();
453     ASSERT_EQ(0, vDecSample->errCount);
454 }
455 
456 /**
457  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_1900
458  * @tc.name      : software decode frame
459  * @tc.desc      : function test
460  */
461 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1900, TestSize.Level0)
462 {
463     VDecNdkSample *vDecSample = new VDecNdkSample();
464 
465     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
466     ASSERT_EQ(AV_ERR_OK, ret);
467     ret = vDecSample->SetVideoDecoderCallback();
468     ASSERT_EQ(AV_ERR_OK, ret);
469     ret = vDecSample->ConfigureVideoDecoder();
470     ASSERT_EQ(AV_ERR_OK, ret);
471     vDecSample->INP_DIR = "/data/test/media/mpeg4_Core_Scalable@level3_320x240_30.m4v";
472     ret = vDecSample->StartVideoDecoder();
473     ASSERT_EQ(AV_ERR_OK, ret);
474     vDecSample->WaitForEOS();
475     ASSERT_EQ(0, vDecSample->errCount);
476 }
477 
478 /**
479  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2000
480  * @tc.name      : software decode frame
481  * @tc.desc      : function test
482  */
483 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2000, TestSize.Level2)
484 {
485     VDecNdkSample *vDecSample = new VDecNdkSample();
486 
487     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
488     ASSERT_EQ(AV_ERR_OK, ret);
489     ret = vDecSample->SetVideoDecoderCallback();
490     ASSERT_EQ(AV_ERR_OK, ret);
491     ret = vDecSample->ConfigureVideoDecoder();
492     ASSERT_EQ(AV_ERR_OK, ret);
493     vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Coding_Efficiency@level6_1600x1200_60.m4v";
494     ret = vDecSample->StartVideoDecoder();
495     ASSERT_EQ(AV_ERR_OK, ret);
496     vDecSample->WaitForEOS();
497     ASSERT_EQ(0, vDecSample->errCount);
498 }
499 
500 /**
501  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2100
502  * @tc.name      : software decode frame
503  * @tc.desc      : function test
504  */
505 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2100, TestSize.Level0)
506 {
507     VDecNdkSample *vDecSample = new VDecNdkSample();
508 
509     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
510     ASSERT_EQ(AV_ERR_OK, ret);
511     ret = vDecSample->SetVideoDecoderCallback();
512     ASSERT_EQ(AV_ERR_OK, ret);
513     ret = vDecSample->ConfigureVideoDecoder();
514     ASSERT_EQ(AV_ERR_OK, ret);
515     vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Core@level2_800x600_30.m4v";
516     ret = vDecSample->StartVideoDecoder();
517     ASSERT_EQ(AV_ERR_OK, ret);
518     vDecSample->WaitForEOS();
519     ASSERT_EQ(0, vDecSample->errCount);
520 }
521 
522 /**
523  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2200
524  * @tc.name      : software decode frame
525  * @tc.desc      : function test
526  */
527 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2200, TestSize.Level2)
528 {
529     VDecNdkSample *vDecSample = new VDecNdkSample();
530 
531     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
532     ASSERT_EQ(AV_ERR_OK, ret);
533     ret = vDecSample->SetVideoDecoderCallback();
534     ASSERT_EQ(AV_ERR_OK, ret);
535     ret = vDecSample->ConfigureVideoDecoder();
536     ASSERT_EQ(AV_ERR_OK, ret);
537     vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Scalable_Texture@level3_1024x576_60.m4v";
538     ret = vDecSample->StartVideoDecoder();
539     ASSERT_EQ(AV_ERR_OK, ret);
540     vDecSample->WaitForEOS();
541     ASSERT_EQ(0, vDecSample->errCount);
542 }
543 
544 /**
545  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2300
546  * @tc.name      : software decode frame
547  * @tc.desc      : function test
548  */
549 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2300, TestSize.Level2)
550 {
551     VDecNdkSample *vDecSample = new VDecNdkSample();
552 
553     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
554     ASSERT_EQ(AV_ERR_OK, ret);
555     ret = vDecSample->SetVideoDecoderCallback();
556     ASSERT_EQ(AV_ERR_OK, ret);
557     ret = vDecSample->ConfigureVideoDecoder();
558     ASSERT_EQ(AV_ERR_OK, ret);
559     vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Simple@level5_320x240_30.m4v";
560     ret = vDecSample->StartVideoDecoder();
561     ASSERT_EQ(AV_ERR_OK, ret);
562     vDecSample->WaitForEOS();
563     ASSERT_EQ(0, vDecSample->errCount);
564 }
565 
566 /**
567  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2400
568  * @tc.name      : software decode odd res stream
569  * @tc.desc      : function test
570  */
571 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2400, TestSize.Level2)
572 {
573     VDecNdkSample *vDecSample = new VDecNdkSample();
574 
575     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
576     ASSERT_EQ(AV_ERR_OK, ret);
577     ret = vDecSample->SetVideoDecoderCallback();
578     ASSERT_EQ(AV_ERR_OK, ret);
579     ret = vDecSample->ConfigureVideoDecoder();
580     ASSERT_EQ(AV_ERR_OK, ret);
581     vDecSample->INP_DIR = "/data/test/media/mpeg4_odd_res_1281x721.m4v";
582     ret = vDecSample->StartVideoDecoder();
583     ASSERT_EQ(AV_ERR_OK, ret);
584     vDecSample->WaitForEOS();
585     ASSERT_EQ(0, vDecSample->errCount);
586 }
587 
588 /**
589  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2500
590  * @tc.name      : software decode res change video
591  * @tc.desc      : function test
592  */
593 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2500, TestSize.Level3)
594 {
595     auto vDecSample = make_shared<VDecNdkSample>();
596     vDecSample->INP_DIR = "/data/test/media/mpeg4_res_change.m4v";
597     vDecSample->DEFAULT_WIDTH = 1920;
598     vDecSample->DEFAULT_HEIGHT = 1080;
599     vDecSample->DEFAULT_FRAME_RATE = 30;
600     vDecSample->SURFACE_OUTPUT = false;
601     vDecSample->checkOutPut = false;
602     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
603     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
604     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
605     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
606     vDecSample->WaitForEOS();
607     ASSERT_EQ(0, vDecSample->errCount);
608 }
609 
610 /**
611  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2600
612  * @tc.name      : software decode err resolution video
613  * @tc.desc      : function test
614  */
615 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2600, TestSize.Level3)
616 {
617     auto vDecSample = make_shared<VDecNdkSample>();
618     vDecSample->INP_DIR = "/data/test/media/mpeg4_err_res.m4v";
619     vDecSample->DEFAULT_WIDTH = 1920;
620     vDecSample->DEFAULT_HEIGHT = 1080;
621     vDecSample->DEFAULT_FRAME_RATE = 30;
622     vDecSample->SURFACE_OUTPUT = false;
623     vDecSample->checkOutPut = false;
624     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
625     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
626     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
627     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
628     vDecSample->WaitForEOS();
629     ASSERT_EQ(0, vDecSample->errCount);
630 }
631 
632 /**
633  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2700
634  * @tc.name      : software decode rotation 90
635  * @tc.desc      : function test
636  */
637 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2700, TestSize.Level2)
638 {
639     auto vDecSample = make_shared<VDecNdkSample>();
640     vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
641     vDecSample->DEFAULT_WIDTH = 1280;
642     vDecSample->DEFAULT_HEIGHT = 720;
643     vDecSample->DEFAULT_FRAME_RATE = 30;
644     vDecSample->SURFACE_OUTPUT = true;
645     vDecSample->checkOutPut = false;
646     vDecSample->DEFAULT_ROTATION = 90;
647     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
648     vDecSample->WaitForEOS();
649     ASSERT_EQ(0, vDecSample->errCount);
650 }
651 
652 /**
653  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2800
654  * @tc.name      : software decode rotation 180
655  * @tc.desc      : function test
656  */
657 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2800, TestSize.Level2)
658 {
659     auto vDecSample = make_shared<VDecNdkSample>();
660     vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
661     vDecSample->DEFAULT_WIDTH = 1280;
662     vDecSample->DEFAULT_HEIGHT = 720;
663     vDecSample->DEFAULT_FRAME_RATE = 30;
664     vDecSample->SURFACE_OUTPUT = true;
665     vDecSample->checkOutPut = false;
666     vDecSample->DEFAULT_ROTATION = 180;
667     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
668     vDecSample->WaitForEOS();
669     ASSERT_EQ(0, vDecSample->errCount);
670 }
671 
672 /**
673  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_2900
674  * @tc.name      : software decode rotation 270
675  * @tc.desc      : function test
676  */
677 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2900, TestSize.Level2)
678 {
679     auto vDecSample = make_shared<VDecNdkSample>();
680     vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
681     vDecSample->DEFAULT_WIDTH = 1280;
682     vDecSample->DEFAULT_HEIGHT = 720;
683     vDecSample->DEFAULT_FRAME_RATE = 30;
684     vDecSample->SURFACE_OUTPUT = true;
685     vDecSample->checkOutPut = false;
686     vDecSample->DEFAULT_ROTATION = 270;
687     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
688     vDecSample->WaitForEOS();
689     ASSERT_EQ(0, vDecSample->errCount);
690 }
691 
692 /**
693  * @tc.number    : VIDEO_MPEG4SWDEC_FUNC_3000
694  * @tc.name      : software decode mpeg2 stream
695  * @tc.desc      : function test
696  */
697 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_3000, TestSize.Level3)
698 {
699     VDecNdkSample *vDecSample = new VDecNdkSample();
700 
701     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
702     ASSERT_EQ(AV_ERR_OK, ret);
703     ret = vDecSample->SetVideoDecoderCallback();
704     ASSERT_EQ(AV_ERR_OK, ret);
705     ret = vDecSample->ConfigureVideoDecoder();
706     ASSERT_EQ(AV_ERR_OK, ret);
707     vDecSample->INP_DIR = "/data/test/media/mpeg2.m2v";
708     ret = vDecSample->StartVideoDecoder();
709     ASSERT_EQ(AV_ERR_OK, ret);
710     vDecSample->WaitForEOS();
711     ASSERT_EQ(0, vDecSample->errCount);
712 }
713 
714 /**
715  * @tc.number    : VIDEO_SWDEC_MPEG4_IPB_0100
716  * @tc.name      : software decode all idr frame
717  * @tc.desc      : function test
718  */
719 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_SWDEC_MPEG4_IPB_0100, TestSize.Level2)
720 {
721     VDecNdkSample *vDecSample = new VDecNdkSample();
722 
723     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
724     ASSERT_EQ(AV_ERR_OK, ret);
725     ret = vDecSample->SetVideoDecoderCallback();
726     ASSERT_EQ(AV_ERR_OK, ret);
727     ret = vDecSample->ConfigureVideoDecoder();
728     ASSERT_EQ(AV_ERR_OK, ret);
729     vDecSample->INP_DIR = "/data/test/media/mpeg4_1280x720_I.m4v";
730     ret = vDecSample->StartVideoDecoder();
731     ASSERT_EQ(AV_ERR_OK, ret);
732     vDecSample->WaitForEOS();
733     ASSERT_EQ(0, vDecSample->errCount);
734 }
735 
736 /**
737  * @tc.number    : VIDEO_MPEG4SWDEC_IPB_0200
738  * @tc.name      : software decode single idr frame
739  * @tc.desc      : function test
740  */
741 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_IPB_0200, TestSize.Level2)
742 {
743     VDecNdkSample *vDecSample = new VDecNdkSample();
744 
745     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
746     ASSERT_EQ(AV_ERR_OK, ret);
747     ret = vDecSample->SetVideoDecoderCallback();
748     ASSERT_EQ(AV_ERR_OK, ret);
749     ret = vDecSample->ConfigureVideoDecoder();
750     ASSERT_EQ(AV_ERR_OK, ret);
751     vDecSample->INP_DIR = "/data/test/media/mpeg4_1280x720_IP.m4v";
752     ret = vDecSample->StartVideoDecoder();
753     ASSERT_EQ(AV_ERR_OK, ret);
754     vDecSample->WaitForEOS();
755     ASSERT_EQ(0, vDecSample->errCount);
756 }
757 
758 /**
759  * @tc.number    : VIDEO_MPEG4SWDEC_IPB_0300
760  * @tc.name      : software decode all idr frame
761  * @tc.desc      : function test
762  */
763 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_IPB_0300, TestSize.Level2)
764 {
765     VDecNdkSample *vDecSample = new VDecNdkSample();
766 
767     int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
768     ASSERT_EQ(AV_ERR_OK, ret);
769     ret = vDecSample->SetVideoDecoderCallback();
770     ASSERT_EQ(AV_ERR_OK, ret);
771     ret = vDecSample->ConfigureVideoDecoder();
772     ASSERT_EQ(AV_ERR_OK, ret);
773     vDecSample->INP_DIR = "/data/test/media/mpeg4_1280x720_IPB.m4v";
774     ret = vDecSample->StartVideoDecoder();
775     ASSERT_EQ(AV_ERR_OK, ret);
776     vDecSample->WaitForEOS();
777     ASSERT_EQ(0, vDecSample->errCount);
778 }
779 
780 /**
781  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0100
782  * @tc.name      : width set -1 height set -1
783  * @tc.desc      : function test
784  */
785 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0100, TestSize.Level2)
786 {
787     auto vDecSample = make_shared<VDecNdkSample>();
788     vDecSample->INP_DIR = INP_DIR_1080_30;
789     vDecSample->DEFAULT_WIDTH = -1;
790     vDecSample->DEFAULT_HEIGHT = -1;
791     vDecSample->DEFAULT_FRAME_RATE = 30;
792     vDecSample->SURFACE_OUTPUT = false;
793     vDecSample->checkOutPut = true;
794     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
795     ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
796 }
797 
798 /**
799  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0200
800  * @tc.name      : width set 0 height set 0
801  * @tc.desc      : function test
802  */
803 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0200, TestSize.Level2)
804 {
805     auto vDecSample = make_shared<VDecNdkSample>();
806     vDecSample->INP_DIR = INP_DIR_1080_30;
807     vDecSample->DEFAULT_WIDTH = 0;
808     vDecSample->DEFAULT_HEIGHT = 0;
809     vDecSample->DEFAULT_FRAME_RATE = 30;
810     vDecSample->SURFACE_OUTPUT = false;
811     vDecSample->checkOutPut = true;
812     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
813     ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
814 }
815 
816 /**
817  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0300
818  * @tc.name      : width set 1 height set 1
819  * @tc.desc      : function test
820  */
821 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0300, TestSize.Level2)
822 {
823     auto vDecSample = make_shared<VDecNdkSample>();
824     vDecSample->INP_DIR = INP_DIR_1080_30;
825     vDecSample->DEFAULT_WIDTH = 1;
826     vDecSample->DEFAULT_HEIGHT = 1;
827     vDecSample->DEFAULT_FRAME_RATE = 30;
828     vDecSample->SURFACE_OUTPUT = false;
829     vDecSample->checkOutPut = true;
830     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
831     ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
832 }
833 
834 /**
835  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0400
836  * @tc.name      : width set 4097 height set 4097
837  * @tc.desc      : function test
838  */
839 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0400, TestSize.Level2)
840 {
841     auto vDecSample = make_shared<VDecNdkSample>();
842     vDecSample->INP_DIR = INP_DIR_1080_30;
843     vDecSample->DEFAULT_WIDTH = 4097;
844     vDecSample->DEFAULT_HEIGHT = 4097;
845     vDecSample->DEFAULT_FRAME_RATE = 30;
846     vDecSample->SURFACE_OUTPUT = false;
847     vDecSample->checkOutPut = true;
848     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
849     ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
850 }
851 
852 /**
853  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0500
854  * @tc.name      : width set 10000 height set 10000
855  * @tc.desc      : function test
856  */
857 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0500, TestSize.Level2)
858 {
859     auto vDecSample = make_shared<VDecNdkSample>();
860     vDecSample->INP_DIR = INP_DIR_1080_30;
861     vDecSample->DEFAULT_WIDTH = 10000;
862     vDecSample->DEFAULT_HEIGHT = 10000;
863     vDecSample->DEFAULT_FRAME_RATE = 30;
864     vDecSample->SURFACE_OUTPUT = false;
865     vDecSample->checkOutPut = true;
866     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
867     ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
868 }
869 
870 /**
871  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0600
872  * @tc.name      : width set 64 height set 64
873  * @tc.desc      : function test
874  */
875 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0600, TestSize.Level2)
876 {
877     auto vDecSample = make_shared<VDecNdkSample>();
878     vDecSample->INP_DIR = INP_DIR_1080_30;
879     vDecSample->DEFAULT_WIDTH = 64;
880     vDecSample->DEFAULT_HEIGHT = 64;
881     vDecSample->DEFAULT_FRAME_RATE = 30;
882     vDecSample->SURFACE_OUTPUT = false;
883     vDecSample->checkOutPut = true;
884     ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
885     ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
886     ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
887     ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
888     vDecSample->WaitForEOS();
889     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
890 }
891 
892 /**
893  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0700
894  * @tc.name      : test mpeg4 decode buffer framerate -1
895  * @tc.desc      : function test
896  */
897 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0700, TestSize.Level2)
898 {
899     if (!access("/system/lib64/media/", 0)) {
900         auto vDecSample = make_shared<VDecAPI11Sample>();
901         vDecSample->INP_DIR = INP_DIR_1080_30;
902         vDecSample->DEFAULT_WIDTH = 1920;
903         vDecSample->DEFAULT_HEIGHT = 1080;
904         vDecSample->DEFAULT_FRAME_RATE = -1;
905         vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
906         vDecSample->SF_OUTPUT = false;
907         ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameMpeg4));
908         vDecSample->WaitForEOS();
909         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
910     }
911 }
912 
913 /**
914  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0800
915  * @tc.name      : test mpeg4 decode buffer framerate 0
916  * @tc.desc      : function test
917  */
918 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0800, TestSize.Level2)
919 {
920     if (!access("/system/lib64/media/", 0)) {
921         auto vDecSample = make_shared<VDecAPI11Sample>();
922         vDecSample->INP_DIR = INP_DIR_1080_30;
923         vDecSample->DEFAULT_WIDTH = 1920;
924         vDecSample->DEFAULT_HEIGHT = 1080;
925         vDecSample->DEFAULT_FRAME_RATE = 0;
926         vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
927         vDecSample->SF_OUTPUT = false;
928         ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameMpeg4));
929         vDecSample->WaitForEOS();
930         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
931     }
932 }
933 
934 /**
935  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_0900
936  * @tc.name      : test mpeg4 decode buffer framerate 0.1
937  * @tc.desc      : function test
938  */
939 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0900, TestSize.Level2)
940 {
941     if (!access("/system/lib64/media/", 0)) {
942         auto vDecSample = make_shared<VDecAPI11Sample>();
943         vDecSample->INP_DIR = INP_DIR_1080_30;
944         vDecSample->DEFAULT_WIDTH = 1920;
945         vDecSample->DEFAULT_HEIGHT = 1080;
946         vDecSample->DEFAULT_FRAME_RATE = 0.1;
947         vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
948         vDecSample->SF_OUTPUT = false;
949         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
950         vDecSample->WaitForEOS();
951         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
952     }
953 }
954 
955 /**
956  * @tc.number    : VIDEO_MPEG4SWDEC_PARA_1000
957  * @tc.name      : test mpeg4 decode buffer framerate 10000
958  * @tc.desc      : function test
959  */
960 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_1000, TestSize.Level2)
961 {
962     if (!access("/system/lib64/media/", 0)) {
963         auto vDecSample = make_shared<VDecAPI11Sample>();
964         vDecSample->INP_DIR = INP_DIR_1080_30;
965         vDecSample->DEFAULT_WIDTH = 1920;
966         vDecSample->DEFAULT_HEIGHT = 1080;
967         vDecSample->DEFAULT_FRAME_RATE = 10000;
968         vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
969         vDecSample->SF_OUTPUT = false;
970         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
971         vDecSample->WaitForEOS();
972         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
973     }
974 }
975 
976 /**
977  * @tc.number    : VIDEO_MPEG4SWDEC_SURF_CHANGE_0100
978  * @tc.name      : surf model change in normal state
979  * @tc.desc      : function test
980  */
981 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0100, TestSize.Level2)
982 {
983     auto vDecSample = make_shared<VDecAPI11Sample>();
984     vDecSample->INP_DIR = INP_DIR_1080_30;
985     vDecSample->DEFAULT_WIDTH = 1920;
986     vDecSample->DEFAULT_HEIGHT = 1080;
987     vDecSample->DEFAULT_FRAME_RATE = 30;
988     vDecSample->SURFACE_OUTPUT = true;
989     vDecSample->autoSwitchSurface = true;
990     vDecSample->AFTER_EOS_DESTORY_CODEC = false;
991     vDecSample->sleepOnFPS = true;
992     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
993     vDecSample->WaitForEOS();
994     ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
995     ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
996     ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
997 }
998 
999 /**
1000  * @tc.number    : VIDEO_MPEG4SWDEC_SURF_CHANGE_0200
1001  * @tc.name      : surf model change in flushed state
1002  * @tc.desc      : function test
1003  */
1004 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0200, TestSize.Level2)
1005 {
1006     auto vDecSample = make_shared<VDecAPI11Sample>();
1007     vDecSample->INP_DIR = INP_DIR_1080_30;
1008     vDecSample->DEFAULT_WIDTH = 1920;
1009     vDecSample->DEFAULT_HEIGHT = 1080;
1010     vDecSample->DEFAULT_FRAME_RATE = 30;
1011     vDecSample->SURFACE_OUTPUT = true;
1012     vDecSample->autoSwitchSurface = true;
1013     vDecSample->sleepOnFPS = true;
1014     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
1015     ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1016     ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1017     ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
1018 }
1019 
1020 /**
1021  * @tc.number    : VIDEO_MPEG4SWDEC_SURF_CHANGE_0300
1022  * @tc.name      : surf model change in runing state
1023  * @tc.desc      : function test
1024  */
1025 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0300, TestSize.Level2)
1026 {
1027     auto vDecSample = make_shared<VDecAPI11Sample>();
1028     vDecSample->INP_DIR = INP_DIR_1080_30;
1029     vDecSample->DEFAULT_WIDTH = 1920;
1030     vDecSample->DEFAULT_HEIGHT = 1080;
1031     vDecSample->DEFAULT_FRAME_RATE = 30;
1032     vDecSample->SURFACE_OUTPUT = false;
1033     vDecSample->autoSwitchSurface = false;
1034     vDecSample->CreateSurface();
1035     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
1036     ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
1037     vDecSample->WaitForEOS();
1038     ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1039 }
1040 
1041 /**
1042  * @tc.number    : VIDEO_MPEG4SWDEC_SURF_CHANGE_0400
1043  * @tc.name      : repeat call setSurface fastly
1044  * @tc.desc      : function test
1045  */
1046 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0400, TestSize.Level2)
1047 {
1048     auto vDecSample = make_shared<VDecAPI11Sample>();
1049     vDecSample->INP_DIR = INP_DIR_1080_30;
1050     vDecSample->DEFAULT_WIDTH = 1920;
1051     vDecSample->DEFAULT_HEIGHT = 1080;
1052     vDecSample->DEFAULT_FRAME_RATE = 30;
1053     vDecSample->SURFACE_OUTPUT = true;
1054     vDecSample->autoSwitchSurface = true;
1055     vDecSample->sleepOnFPS = true;
1056     ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
1057     ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1058     vDecSample->WaitForEOS();
1059 }
1060 } // namespace