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 if (cap_mpeg4 != nullptr) {
84 auto vDecSample = make_shared<VDecNdkSample>();
85 vDecSample->INP_DIR = INP_DIR_1080_30;
86 vDecSample->DEFAULT_WIDTH = 1920;
87 vDecSample->DEFAULT_HEIGHT = 1080;
88 vDecSample->DEFAULT_FRAME_RATE = 30;
89 vDecSample->SURFACE_OUTPUT = false;
90 vDecSample->checkOutPut = true;
91 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
92 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
93 vDecSample->WaitForEOS();
94 ASSERT_EQ(0, vDecSample->errCount);
95 }
96 }
97
98 /**
99 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0200
100 * @tc.name : decode mpeg4 stream, buffer mode, output pixel format is nv21
101 * @tc.desc : function test
102 */
103 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0200, TestSize.Level2)
104 {
105 if (cap_mpeg4 != nullptr) {
106 auto vDecSample = make_shared<VDecNdkSample>();
107 vDecSample->INP_DIR = INP_DIR_1080_30;
108 vDecSample->DEFAULT_WIDTH = 1920;
109 vDecSample->DEFAULT_HEIGHT = 1080;
110 vDecSample->DEFAULT_FRAME_RATE = 30;
111 vDecSample->SURFACE_OUTPUT = false;
112 vDecSample->checkOutPut = true;
113 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
114 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
115 vDecSample->WaitForEOS();
116 ASSERT_EQ(0, vDecSample->errCount);
117 }
118 }
119
120 /**
121 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0300
122 * @tc.name : decode mpeg4 stream, buffer mode, output pixel format is YUVI420
123 * @tc.desc : function test
124 */
125 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0300, TestSize.Level2)
126 {
127 if (cap_mpeg4 != nullptr) {
128 auto vDecSample = make_shared<VDecNdkSample>();
129 vDecSample->INP_DIR = INP_DIR_1080_30;
130 vDecSample->DEFAULT_WIDTH = 1920;
131 vDecSample->DEFAULT_HEIGHT = 1080;
132 vDecSample->DEFAULT_FRAME_RATE = 30;
133 vDecSample->SURFACE_OUTPUT = false;
134 vDecSample->checkOutPut = true;
135 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
136 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
137 vDecSample->WaitForEOS();
138 ASSERT_EQ(0, vDecSample->errCount);
139 }
140 }
141
142 /**
143 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0400
144 * @tc.name : decode mpeg4 stream, buffer mode, output pixel format is RGBA
145 * @tc.desc : function test
146 */
147 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0400, TestSize.Level2)
148 {
149 if (cap_mpeg4 != nullptr) {
150 auto vDecSample = make_shared<VDecNdkSample>();
151 vDecSample->INP_DIR = INP_DIR_1080_30;
152 vDecSample->DEFAULT_WIDTH = 1920;
153 vDecSample->DEFAULT_HEIGHT = 1080;
154 vDecSample->DEFAULT_FRAME_RATE = 30;
155 vDecSample->SURFACE_OUTPUT = false;
156 vDecSample->checkOutPut = false;
157 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
158 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
159 vDecSample->WaitForEOS();
160 ASSERT_EQ(0, vDecSample->errCount);
161 }
162 }
163
164 /**
165 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0500
166 * @tc.name : decode mpeg4 stream, surface mode, output pixel format is NV12
167 * @tc.desc : function test
168 */
169 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0500, TestSize.Level2)
170 {
171 if (cap_mpeg4 != nullptr) {
172 auto vDecSample = make_shared<VDecNdkSample>();
173 vDecSample->INP_DIR = INP_DIR_1080_30;
174 vDecSample->DEFAULT_WIDTH = 1920;
175 vDecSample->DEFAULT_HEIGHT = 1080;
176 vDecSample->DEFAULT_FRAME_RATE = 30;
177 vDecSample->SURFACE_OUTPUT = true;
178 vDecSample->checkOutPut = true;
179 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
180 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
181 vDecSample->WaitForEOS();
182 ASSERT_EQ(0, vDecSample->errCount);
183 }
184 }
185
186 /**
187 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0600
188 * @tc.name : decode mpeg4 stream, surface mode, output pixel format is NV21
189 * @tc.desc : function test
190 */
191 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0600, TestSize.Level2)
192 {
193 if (cap_mpeg4 != nullptr) {
194 auto vDecSample = make_shared<VDecNdkSample>();
195 vDecSample->INP_DIR = INP_DIR_1080_30;
196 vDecSample->DEFAULT_WIDTH = 1920;
197 vDecSample->DEFAULT_HEIGHT = 1080;
198 vDecSample->DEFAULT_FRAME_RATE = 30;
199 vDecSample->SURFACE_OUTPUT = true;
200 vDecSample->checkOutPut = true;
201 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
202 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
203 vDecSample->WaitForEOS();
204 ASSERT_EQ(0, vDecSample->errCount);
205 }
206 }
207
208 /**
209 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0700
210 * @tc.name : decode mpeg4 stream, surface mode, output pixel format is YUVI420
211 * @tc.desc : function test
212 */
213 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0700, TestSize.Level2)
214 {
215 if (cap_mpeg4 != nullptr) {
216 auto vDecSample = make_shared<VDecNdkSample>();
217 vDecSample->INP_DIR = INP_DIR_1080_30;
218 vDecSample->DEFAULT_WIDTH = 1920;
219 vDecSample->DEFAULT_HEIGHT = 1080;
220 vDecSample->DEFAULT_FRAME_RATE = 30;
221 vDecSample->SURFACE_OUTPUT = true;
222 vDecSample->checkOutPut = true;
223 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
224 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
225 vDecSample->WaitForEOS();
226 ASSERT_EQ(0, vDecSample->errCount);
227 }
228 }
229
230 /**
231 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0800
232 * @tc.name : decode mpeg4 stream, surface mode, output pixel format is RGBA
233 * @tc.desc : function test
234 */
235 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0800, TestSize.Level2)
236 {
237 if (cap_mpeg4 != nullptr) {
238 auto vDecSample = make_shared<VDecNdkSample>();
239 vDecSample->INP_DIR = INP_DIR_1080_30;
240 vDecSample->DEFAULT_WIDTH = 1920;
241 vDecSample->DEFAULT_HEIGHT = 1080;
242 vDecSample->DEFAULT_FRAME_RATE = 30;
243 vDecSample->SURFACE_OUTPUT = true;
244 vDecSample->checkOutPut = false;
245 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
246 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
247 vDecSample->WaitForEOS();
248 ASSERT_EQ(0, vDecSample->errCount);
249 }
250 }
251
252 /**
253 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_0900
254 * @tc.name : software decode frame
255 * @tc.desc : function test
256 */
257 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_0900, TestSize.Level0)
258 {
259 if (cap_mpeg4 != nullptr) {
260 VDecNdkSample *vDecSample = new VDecNdkSample();
261
262 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
263 ASSERT_EQ(AV_ERR_OK, ret);
264 ret = vDecSample->SetVideoDecoderCallback();
265 ASSERT_EQ(AV_ERR_OK, ret);
266 ret = vDecSample->ConfigureVideoDecoder();
267 ASSERT_EQ(AV_ERR_OK, ret);
268 vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
269 ret = vDecSample->StartVideoDecoder();
270 ASSERT_EQ(AV_ERR_OK, ret);
271 vDecSample->WaitForEOS();
272 ASSERT_EQ(0, vDecSample->errCount);
273 }
274 }
275
276 /**
277 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1000
278 * @tc.name : software decode frame
279 * @tc.desc : function test
280 */
281 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1000, TestSize.Level2)
282 {
283 if (cap_mpeg4 != nullptr) {
284 VDecNdkSample *vDecSample = new VDecNdkSample();
285
286 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
287 ASSERT_EQ(AV_ERR_OK, ret);
288 ret = vDecSample->SetVideoDecoderCallback();
289 ASSERT_EQ(AV_ERR_OK, ret);
290 ret = vDecSample->ConfigureVideoDecoder();
291 ASSERT_EQ(AV_ERR_OK, ret);
292 vDecSample->INP_DIR = "/data/test/media/mpeg4_simple_scalable@level2_352x288_60.m4v";
293 ret = vDecSample->StartVideoDecoder();
294 ASSERT_EQ(AV_ERR_OK, ret);
295 vDecSample->WaitForEOS();
296 ASSERT_EQ(0, vDecSample->errCount);
297 }
298 }
299
300 /**
301 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1100
302 * @tc.name : software decode frame
303 * @tc.desc : function test
304 */
305 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1100, TestSize.Level2)
306 {
307 if (cap_mpeg4 != nullptr) {
308 VDecNdkSample *vDecSample = new VDecNdkSample();
309
310 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
311 ASSERT_EQ(AV_ERR_OK, ret);
312 ret = vDecSample->SetVideoDecoderCallback();
313 ASSERT_EQ(AV_ERR_OK, ret);
314 ret = vDecSample->ConfigureVideoDecoder();
315 ASSERT_EQ(AV_ERR_OK, ret);
316 vDecSample->INP_DIR = "/data/test/media/mpeg4_core@level1_176x144_30.m4v";
317 ret = vDecSample->StartVideoDecoder();
318 ASSERT_EQ(AV_ERR_OK, ret);
319 vDecSample->WaitForEOS();
320 ASSERT_EQ(0, vDecSample->errCount);
321 }
322 }
323
324 /**
325 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1200
326 * @tc.name : software decode frame
327 * @tc.desc : function test
328 */
329 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1200, TestSize.Level0)
330 {
331 if (cap_mpeg4 != nullptr) {
332 VDecNdkSample *vDecSample = new VDecNdkSample();
333
334 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
335 ASSERT_EQ(AV_ERR_OK, ret);
336 ret = vDecSample->SetVideoDecoderCallback();
337 ASSERT_EQ(AV_ERR_OK, ret);
338 ret = vDecSample->ConfigureVideoDecoder();
339 ASSERT_EQ(AV_ERR_OK, ret);
340 vDecSample->INP_DIR = "/data/test/media/mpeg4_main@level4_1920x1080_30.m4v";
341 ret = vDecSample->StartVideoDecoder();
342 ASSERT_EQ(AV_ERR_OK, ret);
343 vDecSample->WaitForEOS();
344 ASSERT_EQ(0, vDecSample->errCount);
345 }
346 }
347
348 /**
349 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1300
350 * @tc.name : software decode frame
351 * @tc.desc : function test
352 */
353 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1300, TestSize.Level2)
354 {
355 if (cap_mpeg4 != nullptr) {
356 VDecNdkSample *vDecSample = new VDecNdkSample();
357
358 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
359 ASSERT_EQ(AV_ERR_OK, ret);
360 ret = vDecSample->SetVideoDecoderCallback();
361 ASSERT_EQ(AV_ERR_OK, ret);
362 ret = vDecSample->ConfigureVideoDecoder();
363 ASSERT_EQ(AV_ERR_OK, ret);
364 vDecSample->INP_DIR = "/data/test/media/mpeg4_N_bit@level2_640x480_60.m4v";
365 ret = vDecSample->StartVideoDecoder();
366 ASSERT_EQ(AV_ERR_OK, ret);
367 vDecSample->WaitForEOS();
368 ASSERT_EQ(0, vDecSample->errCount);
369 }
370 }
371
372 /**
373 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1400
374 * @tc.name : software decode frame
375 * @tc.desc : function test
376 */
377 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1400, TestSize.Level2)
378 {
379 if (cap_mpeg4 != nullptr) {
380 VDecNdkSample *vDecSample = new VDecNdkSample();
381
382 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
383 ASSERT_EQ(AV_ERR_OK, ret);
384 ret = vDecSample->SetVideoDecoderCallback();
385 ASSERT_EQ(AV_ERR_OK, ret);
386 ret = vDecSample->ConfigureVideoDecoder();
387 ASSERT_EQ(AV_ERR_OK, ret);
388 vDecSample->INP_DIR = "/data/test/media/mpeg4_Hybrid@level2_720x480_30.m4v";
389 ret = vDecSample->StartVideoDecoder();
390 ASSERT_EQ(AV_ERR_OK, ret);
391 vDecSample->WaitForEOS();
392 ASSERT_EQ(0, vDecSample->errCount);
393 }
394 }
395
396 /**
397 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1500
398 * @tc.name : software decode frame
399 * @tc.desc : function test
400 */
401 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1500, TestSize.Level2)
402 {
403 if (cap_mpeg4 != nullptr) {
404 VDecNdkSample *vDecSample = new VDecNdkSample();
405
406 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
407 ASSERT_EQ(AV_ERR_OK, ret);
408 ret = vDecSample->SetVideoDecoderCallback();
409 ASSERT_EQ(AV_ERR_OK, ret);
410 ret = vDecSample->ConfigureVideoDecoder();
411 ASSERT_EQ(AV_ERR_OK, ret);
412 vDecSample->INP_DIR = "/data/test/media/mpeg4_Basic_Animated_Texture@level2_720x576_30.m4v";
413 ret = vDecSample->StartVideoDecoder();
414 ASSERT_EQ(AV_ERR_OK, ret);
415 vDecSample->WaitForEOS();
416 ASSERT_EQ(0, vDecSample->errCount);
417 }
418 }
419
420 /**
421 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1600
422 * @tc.name : software decode frame
423 * @tc.desc : function test
424 */
425 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1600, TestSize.Level2)
426 {
427 if (cap_mpeg4 != nullptr) {
428 VDecNdkSample *vDecSample = new VDecNdkSample();
429
430 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
431 ASSERT_EQ(AV_ERR_OK, ret);
432 ret = vDecSample->SetVideoDecoderCallback();
433 ASSERT_EQ(AV_ERR_OK, ret);
434 ret = vDecSample->ConfigureVideoDecoder();
435 ASSERT_EQ(AV_ERR_OK, ret);
436 vDecSample->INP_DIR = "/data/test/media/mpeg4_Scalable_Texture@level1_1600x900_60.m4v";
437 ret = vDecSample->StartVideoDecoder();
438 ASSERT_EQ(AV_ERR_OK, ret);
439 vDecSample->WaitForEOS();
440 ASSERT_EQ(0, vDecSample->errCount);
441 }
442 }
443
444 /**
445 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1700
446 * @tc.name : software decode frame
447 * @tc.desc : function test
448 */
449 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1700, TestSize.Level0)
450 {
451 if (cap_mpeg4 != nullptr) {
452 VDecNdkSample *vDecSample = new VDecNdkSample();
453
454 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
455 ASSERT_EQ(AV_ERR_OK, ret);
456 ret = vDecSample->SetVideoDecoderCallback();
457 ASSERT_EQ(AV_ERR_OK, ret);
458 ret = vDecSample->ConfigureVideoDecoder();
459 ASSERT_EQ(AV_ERR_OK, ret);
460 vDecSample->INP_DIR = "/data/test/media/mpeg4_Simple_FA@level2_1024x768_30.m4v";
461 ret = vDecSample->StartVideoDecoder();
462 ASSERT_EQ(AV_ERR_OK, ret);
463 vDecSample->WaitForEOS();
464 ASSERT_EQ(0, vDecSample->errCount);
465 }
466 }
467
468 /**
469 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1800
470 * @tc.name : software decode frame
471 * @tc.desc : function test
472 */
473 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1800, TestSize.Level2)
474 {
475 if (cap_mpeg4 != nullptr) {
476 VDecNdkSample *vDecSample = new VDecNdkSample();
477
478 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
479 ASSERT_EQ(AV_ERR_OK, ret);
480 ret = vDecSample->SetVideoDecoderCallback();
481 ASSERT_EQ(AV_ERR_OK, ret);
482 ret = vDecSample->ConfigureVideoDecoder();
483 ASSERT_EQ(AV_ERR_OK, ret);
484 vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Real_Time_Simple@level4_1440x1080_60.m4v";
485 ret = vDecSample->StartVideoDecoder();
486 ASSERT_EQ(AV_ERR_OK, ret);
487 vDecSample->WaitForEOS();
488 ASSERT_EQ(0, vDecSample->errCount);
489 }
490 }
491
492 /**
493 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_1900
494 * @tc.name : software decode frame
495 * @tc.desc : function test
496 */
497 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_1900, TestSize.Level0)
498 {
499 if (cap_mpeg4 != nullptr) {
500 VDecNdkSample *vDecSample = new VDecNdkSample();
501
502 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
503 ASSERT_EQ(AV_ERR_OK, ret);
504 ret = vDecSample->SetVideoDecoderCallback();
505 ASSERT_EQ(AV_ERR_OK, ret);
506 ret = vDecSample->ConfigureVideoDecoder();
507 ASSERT_EQ(AV_ERR_OK, ret);
508 vDecSample->INP_DIR = "/data/test/media/mpeg4_Core_Scalable@level3_320x240_30.m4v";
509 ret = vDecSample->StartVideoDecoder();
510 ASSERT_EQ(AV_ERR_OK, ret);
511 vDecSample->WaitForEOS();
512 ASSERT_EQ(0, vDecSample->errCount);
513 }
514 }
515
516 /**
517 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2000
518 * @tc.name : software decode frame
519 * @tc.desc : function test
520 */
521 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2000, TestSize.Level2)
522 {
523 if (cap_mpeg4 != nullptr) {
524 VDecNdkSample *vDecSample = new VDecNdkSample();
525
526 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
527 ASSERT_EQ(AV_ERR_OK, ret);
528 ret = vDecSample->SetVideoDecoderCallback();
529 ASSERT_EQ(AV_ERR_OK, ret);
530 ret = vDecSample->ConfigureVideoDecoder();
531 ASSERT_EQ(AV_ERR_OK, ret);
532 vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Coding_Efficiency@level6_1600x1200_60.m4v";
533 ret = vDecSample->StartVideoDecoder();
534 ASSERT_EQ(AV_ERR_OK, ret);
535 vDecSample->WaitForEOS();
536 ASSERT_EQ(0, vDecSample->errCount);
537 }
538 }
539
540 /**
541 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2100
542 * @tc.name : software decode frame
543 * @tc.desc : function test
544 */
545 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2100, TestSize.Level0)
546 {
547 if (cap_mpeg4 != nullptr) {
548 VDecNdkSample *vDecSample = new VDecNdkSample();
549
550 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
551 ASSERT_EQ(AV_ERR_OK, ret);
552 ret = vDecSample->SetVideoDecoderCallback();
553 ASSERT_EQ(AV_ERR_OK, ret);
554 ret = vDecSample->ConfigureVideoDecoder();
555 ASSERT_EQ(AV_ERR_OK, ret);
556 vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Core@level2_800x600_30.m4v";
557 ret = vDecSample->StartVideoDecoder();
558 ASSERT_EQ(AV_ERR_OK, ret);
559 vDecSample->WaitForEOS();
560 ASSERT_EQ(0, vDecSample->errCount);
561 }
562 }
563
564 /**
565 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2200
566 * @tc.name : software decode frame
567 * @tc.desc : function test
568 */
569 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2200, TestSize.Level2)
570 {
571 if (cap_mpeg4 != nullptr) {
572 VDecNdkSample *vDecSample = new VDecNdkSample();
573
574 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
575 ASSERT_EQ(AV_ERR_OK, ret);
576 ret = vDecSample->SetVideoDecoderCallback();
577 ASSERT_EQ(AV_ERR_OK, ret);
578 ret = vDecSample->ConfigureVideoDecoder();
579 ASSERT_EQ(AV_ERR_OK, ret);
580 vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Scalable_Texture@level3_1024x576_60.m4v";
581 ret = vDecSample->StartVideoDecoder();
582 ASSERT_EQ(AV_ERR_OK, ret);
583 vDecSample->WaitForEOS();
584 ASSERT_EQ(0, vDecSample->errCount);
585 }
586 }
587
588 /**
589 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2300
590 * @tc.name : software decode frame
591 * @tc.desc : function test
592 */
593 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2300, TestSize.Level2)
594 {
595 if (cap_mpeg4 != nullptr) {
596 VDecNdkSample *vDecSample = new VDecNdkSample();
597
598 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
599 ASSERT_EQ(AV_ERR_OK, ret);
600 ret = vDecSample->SetVideoDecoderCallback();
601 ASSERT_EQ(AV_ERR_OK, ret);
602 ret = vDecSample->ConfigureVideoDecoder();
603 ASSERT_EQ(AV_ERR_OK, ret);
604 vDecSample->INP_DIR = "/data/test/media/mpeg4_Advanced_Simple@level5_320x240_30.m4v";
605 ret = vDecSample->StartVideoDecoder();
606 ASSERT_EQ(AV_ERR_OK, ret);
607 vDecSample->WaitForEOS();
608 ASSERT_EQ(0, vDecSample->errCount);
609 }
610 }
611
612 /**
613 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2400
614 * @tc.name : software decode odd res stream
615 * @tc.desc : function test
616 */
617 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2400, TestSize.Level2)
618 {
619 if (cap_mpeg4 != nullptr) {
620 VDecNdkSample *vDecSample = new VDecNdkSample();
621
622 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
623 ASSERT_EQ(AV_ERR_OK, ret);
624 ret = vDecSample->SetVideoDecoderCallback();
625 ASSERT_EQ(AV_ERR_OK, ret);
626 ret = vDecSample->ConfigureVideoDecoder();
627 ASSERT_EQ(AV_ERR_OK, ret);
628 vDecSample->INP_DIR = "/data/test/media/mpeg4_odd_res_1281x721.m4v";
629 ret = vDecSample->StartVideoDecoder();
630 ASSERT_EQ(AV_ERR_OK, ret);
631 vDecSample->WaitForEOS();
632 ASSERT_EQ(0, vDecSample->errCount);
633 }
634 }
635
636 /**
637 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2500
638 * @tc.name : software decode res change video
639 * @tc.desc : function test
640 */
641 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2500, TestSize.Level3)
642 {
643 if (cap_mpeg4 != nullptr) {
644 auto vDecSample = make_shared<VDecNdkSample>();
645 vDecSample->INP_DIR = "/data/test/media/mpeg4_res_change.m4v";
646 vDecSample->DEFAULT_WIDTH = 1920;
647 vDecSample->DEFAULT_HEIGHT = 1080;
648 vDecSample->DEFAULT_FRAME_RATE = 30;
649 vDecSample->SURFACE_OUTPUT = false;
650 vDecSample->checkOutPut = false;
651 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
652 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
653 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
654 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
655 vDecSample->WaitForEOS();
656 ASSERT_EQ(0, vDecSample->errCount);
657 }
658 }
659
660 /**
661 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2600
662 * @tc.name : software decode err resolution video
663 * @tc.desc : function test
664 */
665 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2600, TestSize.Level3)
666 {
667 if (cap_mpeg4 != nullptr) {
668 auto vDecSample = make_shared<VDecNdkSample>();
669 vDecSample->INP_DIR = "/data/test/media/mpeg4_err_res.m4v";
670 vDecSample->DEFAULT_WIDTH = 1920;
671 vDecSample->DEFAULT_HEIGHT = 1080;
672 vDecSample->DEFAULT_FRAME_RATE = 30;
673 vDecSample->SURFACE_OUTPUT = false;
674 vDecSample->checkOutPut = false;
675 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
676 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
677 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
678 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
679 vDecSample->WaitForEOS();
680 ASSERT_EQ(0, vDecSample->errCount);
681 }
682 }
683
684 /**
685 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2700
686 * @tc.name : software decode rotation 90
687 * @tc.desc : function test
688 */
689 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2700, TestSize.Level2)
690 {
691 if (cap_mpeg4 != nullptr) {
692 auto vDecSample = make_shared<VDecNdkSample>();
693 vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
694 vDecSample->DEFAULT_WIDTH = 1280;
695 vDecSample->DEFAULT_HEIGHT = 720;
696 vDecSample->DEFAULT_FRAME_RATE = 30;
697 vDecSample->SURFACE_OUTPUT = true;
698 vDecSample->checkOutPut = false;
699 vDecSample->DEFAULT_ROTATION = 90;
700 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
701 vDecSample->WaitForEOS();
702 ASSERT_EQ(0, vDecSample->errCount);
703 }
704 }
705
706 /**
707 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2800
708 * @tc.name : software decode rotation 180
709 * @tc.desc : function test
710 */
711 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2800, TestSize.Level2)
712 {
713 if (cap_mpeg4 != nullptr) {
714 auto vDecSample = make_shared<VDecNdkSample>();
715 vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
716 vDecSample->DEFAULT_WIDTH = 1280;
717 vDecSample->DEFAULT_HEIGHT = 720;
718 vDecSample->DEFAULT_FRAME_RATE = 30;
719 vDecSample->SURFACE_OUTPUT = true;
720 vDecSample->checkOutPut = false;
721 vDecSample->DEFAULT_ROTATION = 180;
722 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
723 vDecSample->WaitForEOS();
724 ASSERT_EQ(0, vDecSample->errCount);
725 }
726 }
727
728 /**
729 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_2900
730 * @tc.name : software decode rotation 270
731 * @tc.desc : function test
732 */
733 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_2900, TestSize.Level2)
734 {
735 if (cap_mpeg4 != nullptr) {
736 auto vDecSample = make_shared<VDecNdkSample>();
737 vDecSample->INP_DIR = "/data/test/media/mpeg4_simple@level6_1280x720_30.m4v";
738 vDecSample->DEFAULT_WIDTH = 1280;
739 vDecSample->DEFAULT_HEIGHT = 720;
740 vDecSample->DEFAULT_FRAME_RATE = 30;
741 vDecSample->SURFACE_OUTPUT = true;
742 vDecSample->checkOutPut = false;
743 vDecSample->DEFAULT_ROTATION = 270;
744 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
745 vDecSample->WaitForEOS();
746 ASSERT_EQ(0, vDecSample->errCount);
747 }
748 }
749
750 /**
751 * @tc.number : VIDEO_MPEG4SWDEC_FUNC_3000
752 * @tc.name : software decode mpeg2 stream
753 * @tc.desc : function test
754 */
755 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_FUNC_3000, TestSize.Level3)
756 {
757 if (cap_mpeg4 != nullptr) {
758 VDecNdkSample *vDecSample = new VDecNdkSample();
759
760 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
761 ASSERT_EQ(AV_ERR_OK, ret);
762 ret = vDecSample->SetVideoDecoderCallback();
763 ASSERT_EQ(AV_ERR_OK, ret);
764 ret = vDecSample->ConfigureVideoDecoder();
765 ASSERT_EQ(AV_ERR_OK, ret);
766 vDecSample->INP_DIR = "/data/test/media/mpeg2.m2v";
767 ret = vDecSample->StartVideoDecoder();
768 ASSERT_EQ(AV_ERR_OK, ret);
769 vDecSample->WaitForEOS();
770 ASSERT_EQ(0, vDecSample->errCount);
771 }
772 }
773
774 /**
775 * @tc.number : VIDEO_SWDEC_MPEG4_IPB_0100
776 * @tc.name : software decode all idr frame
777 * @tc.desc : function test
778 */
779 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_SWDEC_MPEG4_IPB_0100, TestSize.Level2)
780 {
781 if (cap_mpeg4 != nullptr) {
782 VDecNdkSample *vDecSample = new VDecNdkSample();
783
784 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
785 ASSERT_EQ(AV_ERR_OK, ret);
786 ret = vDecSample->SetVideoDecoderCallback();
787 ASSERT_EQ(AV_ERR_OK, ret);
788 ret = vDecSample->ConfigureVideoDecoder();
789 ASSERT_EQ(AV_ERR_OK, ret);
790 vDecSample->INP_DIR = "/data/test/media/mpeg4_1280x720_I.m4v";
791 ret = vDecSample->StartVideoDecoder();
792 ASSERT_EQ(AV_ERR_OK, ret);
793 vDecSample->WaitForEOS();
794 ASSERT_EQ(0, vDecSample->errCount);
795 }
796 }
797
798 /**
799 * @tc.number : VIDEO_MPEG4SWDEC_IPB_0200
800 * @tc.name : software decode single idr frame
801 * @tc.desc : function test
802 */
803 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_IPB_0200, TestSize.Level2)
804 {
805 if (cap_mpeg4 != nullptr) {
806 VDecNdkSample *vDecSample = new VDecNdkSample();
807
808 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
809 ASSERT_EQ(AV_ERR_OK, ret);
810 ret = vDecSample->SetVideoDecoderCallback();
811 ASSERT_EQ(AV_ERR_OK, ret);
812 ret = vDecSample->ConfigureVideoDecoder();
813 ASSERT_EQ(AV_ERR_OK, ret);
814 vDecSample->INP_DIR = "/data/test/media/mpeg4_1280x720_IP.m4v";
815 ret = vDecSample->StartVideoDecoder();
816 ASSERT_EQ(AV_ERR_OK, ret);
817 vDecSample->WaitForEOS();
818 ASSERT_EQ(0, vDecSample->errCount);
819 }
820 }
821
822 /**
823 * @tc.number : VIDEO_MPEG4SWDEC_IPB_0300
824 * @tc.name : software decode all idr frame
825 * @tc.desc : function test
826 */
827 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_IPB_0300, TestSize.Level2)
828 {
829 if (cap_mpeg4 != nullptr) {
830 VDecNdkSample *vDecSample = new VDecNdkSample();
831
832 int32_t ret = vDecSample->CreateVideoDecoder(g_codecNameMpeg4);
833 ASSERT_EQ(AV_ERR_OK, ret);
834 ret = vDecSample->SetVideoDecoderCallback();
835 ASSERT_EQ(AV_ERR_OK, ret);
836 ret = vDecSample->ConfigureVideoDecoder();
837 ASSERT_EQ(AV_ERR_OK, ret);
838 vDecSample->INP_DIR = "/data/test/media/mpeg4_1280x720_IPB.m4v";
839 ret = vDecSample->StartVideoDecoder();
840 ASSERT_EQ(AV_ERR_OK, ret);
841 vDecSample->WaitForEOS();
842 ASSERT_EQ(0, vDecSample->errCount);
843 }
844 }
845
846 /**
847 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0100
848 * @tc.name : width set -1 height set -1
849 * @tc.desc : function test
850 */
851 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0100, TestSize.Level2)
852 {
853 if (cap_mpeg4 != nullptr) {
854 auto vDecSample = make_shared<VDecNdkSample>();
855 vDecSample->INP_DIR = INP_DIR_1080_30;
856 vDecSample->DEFAULT_WIDTH = -1;
857 vDecSample->DEFAULT_HEIGHT = -1;
858 vDecSample->DEFAULT_FRAME_RATE = 30;
859 vDecSample->SURFACE_OUTPUT = false;
860 vDecSample->checkOutPut = true;
861 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
862 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
863 }
864 }
865
866 /**
867 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0200
868 * @tc.name : width set 0 height set 0
869 * @tc.desc : function test
870 */
871 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0200, TestSize.Level2)
872 {
873 if (cap_mpeg4 != nullptr) {
874 auto vDecSample = make_shared<VDecNdkSample>();
875 vDecSample->INP_DIR = INP_DIR_1080_30;
876 vDecSample->DEFAULT_WIDTH = 0;
877 vDecSample->DEFAULT_HEIGHT = 0;
878 vDecSample->DEFAULT_FRAME_RATE = 30;
879 vDecSample->SURFACE_OUTPUT = false;
880 vDecSample->checkOutPut = true;
881 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
882 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
883 }
884 }
885
886 /**
887 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0300
888 * @tc.name : width set 1 height set 1
889 * @tc.desc : function test
890 */
891 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0300, TestSize.Level2)
892 {
893 if (cap_mpeg4 != nullptr) {
894 auto vDecSample = make_shared<VDecNdkSample>();
895 vDecSample->INP_DIR = INP_DIR_1080_30;
896 vDecSample->DEFAULT_WIDTH = 1;
897 vDecSample->DEFAULT_HEIGHT = 1;
898 vDecSample->DEFAULT_FRAME_RATE = 30;
899 vDecSample->SURFACE_OUTPUT = false;
900 vDecSample->checkOutPut = true;
901 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
902 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
903 }
904 }
905
906 /**
907 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0400
908 * @tc.name : width set 4097 height set 4097
909 * @tc.desc : function test
910 */
911 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0400, TestSize.Level2)
912 {
913 if (cap_mpeg4 != nullptr) {
914 auto vDecSample = make_shared<VDecNdkSample>();
915 vDecSample->INP_DIR = INP_DIR_1080_30;
916 vDecSample->DEFAULT_WIDTH = 4097;
917 vDecSample->DEFAULT_HEIGHT = 4097;
918 vDecSample->DEFAULT_FRAME_RATE = 30;
919 vDecSample->SURFACE_OUTPUT = false;
920 vDecSample->checkOutPut = true;
921 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
922 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
923 }
924 }
925
926 /**
927 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0500
928 * @tc.name : width set 10000 height set 10000
929 * @tc.desc : function test
930 */
931 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0500, TestSize.Level2)
932 {
933 if (cap_mpeg4 != nullptr) {
934 auto vDecSample = make_shared<VDecNdkSample>();
935 vDecSample->INP_DIR = INP_DIR_1080_30;
936 vDecSample->DEFAULT_WIDTH = 10000;
937 vDecSample->DEFAULT_HEIGHT = 10000;
938 vDecSample->DEFAULT_FRAME_RATE = 30;
939 vDecSample->SURFACE_OUTPUT = false;
940 vDecSample->checkOutPut = true;
941 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
942 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
943 }
944 }
945
946 /**
947 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0600
948 * @tc.name : width set 64 height set 64
949 * @tc.desc : function test
950 */
951 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0600, TestSize.Level2)
952 {
953 if (cap_mpeg4 != nullptr) {
954 auto vDecSample = make_shared<VDecNdkSample>();
955 vDecSample->INP_DIR = INP_DIR_1080_30;
956 vDecSample->DEFAULT_WIDTH = 64;
957 vDecSample->DEFAULT_HEIGHT = 64;
958 vDecSample->DEFAULT_FRAME_RATE = 30;
959 vDecSample->SURFACE_OUTPUT = false;
960 vDecSample->checkOutPut = true;
961 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
962 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
963 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
964 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
965 vDecSample->WaitForEOS();
966 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
967 }
968 }
969
970 /**
971 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0700
972 * @tc.name : test mpeg4 decode buffer framerate -1
973 * @tc.desc : function test
974 */
975 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0700, TestSize.Level2)
976 {
977 if (cap_mpeg4 != nullptr) {
978 if (!access("/system/lib64/media/", 0)) {
979 auto vDecSample = make_shared<VDecAPI11Sample>();
980 vDecSample->INP_DIR = INP_DIR_1080_30;
981 vDecSample->DEFAULT_WIDTH = 1920;
982 vDecSample->DEFAULT_HEIGHT = 1080;
983 vDecSample->DEFAULT_FRAME_RATE = -1;
984 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
985 vDecSample->SF_OUTPUT = false;
986 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameMpeg4));
987 vDecSample->WaitForEOS();
988 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
989 }
990 }
991 }
992
993 /**
994 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0800
995 * @tc.name : test mpeg4 decode buffer framerate 0
996 * @tc.desc : function test
997 */
998 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0800, TestSize.Level2)
999 {
1000 if (cap_mpeg4 != nullptr) {
1001 if (!access("/system/lib64/media/", 0)) {
1002 auto vDecSample = make_shared<VDecAPI11Sample>();
1003 vDecSample->INP_DIR = INP_DIR_1080_30;
1004 vDecSample->DEFAULT_WIDTH = 1920;
1005 vDecSample->DEFAULT_HEIGHT = 1080;
1006 vDecSample->DEFAULT_FRAME_RATE = 0;
1007 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1008 vDecSample->SF_OUTPUT = false;
1009 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameMpeg4));
1010 vDecSample->WaitForEOS();
1011 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1012 }
1013 }
1014 }
1015
1016 /**
1017 * @tc.number : VIDEO_MPEG4SWDEC_PARA_0900
1018 * @tc.name : test mpeg4 decode buffer framerate 0.1
1019 * @tc.desc : function test
1020 */
1021 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_0900, TestSize.Level2)
1022 {
1023 if (cap_mpeg4 != nullptr) {
1024 if (!access("/system/lib64/media/", 0)) {
1025 auto vDecSample = make_shared<VDecAPI11Sample>();
1026 vDecSample->INP_DIR = INP_DIR_1080_30;
1027 vDecSample->DEFAULT_WIDTH = 1920;
1028 vDecSample->DEFAULT_HEIGHT = 1080;
1029 vDecSample->DEFAULT_FRAME_RATE = 0.1;
1030 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1031 vDecSample->SF_OUTPUT = false;
1032 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
1033 vDecSample->WaitForEOS();
1034 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1035 }
1036 }
1037 }
1038
1039 /**
1040 * @tc.number : VIDEO_MPEG4SWDEC_PARA_1000
1041 * @tc.name : test mpeg4 decode buffer framerate 10000
1042 * @tc.desc : function test
1043 */
1044 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_PARA_1000, TestSize.Level2)
1045 {
1046 if (cap_mpeg4 != nullptr) {
1047 if (!access("/system/lib64/media/", 0)) {
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 = 10000;
1053 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1054 vDecSample->SF_OUTPUT = false;
1055 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
1056 vDecSample->WaitForEOS();
1057 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1058 }
1059 }
1060 }
1061
1062 /**
1063 * @tc.number : VIDEO_MPEG4SWDEC_SURF_CHANGE_0100
1064 * @tc.name : surf model change in normal state
1065 * @tc.desc : function test
1066 */
1067 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0100, TestSize.Level2)
1068 {
1069 if (cap_mpeg4 != nullptr) {
1070 auto vDecSample = make_shared<VDecAPI11Sample>();
1071 vDecSample->INP_DIR = INP_DIR_1080_30;
1072 vDecSample->DEFAULT_WIDTH = 1920;
1073 vDecSample->DEFAULT_HEIGHT = 1080;
1074 vDecSample->DEFAULT_FRAME_RATE = 30;
1075 vDecSample->SURFACE_OUTPUT = true;
1076 vDecSample->autoSwitchSurface = true;
1077 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
1078 vDecSample->sleepOnFPS = true;
1079 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
1080 vDecSample->WaitForEOS();
1081 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
1082 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
1083 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
1084 }
1085 }
1086
1087 /**
1088 * @tc.number : VIDEO_MPEG4SWDEC_SURF_CHANGE_0200
1089 * @tc.name : surf model change in flushed state
1090 * @tc.desc : function test
1091 */
1092 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0200, TestSize.Level2)
1093 {
1094 if (cap_mpeg4 != nullptr) {
1095 auto vDecSample = make_shared<VDecAPI11Sample>();
1096 vDecSample->INP_DIR = INP_DIR_1080_30;
1097 vDecSample->DEFAULT_WIDTH = 1920;
1098 vDecSample->DEFAULT_HEIGHT = 1080;
1099 vDecSample->DEFAULT_FRAME_RATE = 30;
1100 vDecSample->SURFACE_OUTPUT = true;
1101 vDecSample->autoSwitchSurface = true;
1102 vDecSample->sleepOnFPS = true;
1103 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
1104 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1105 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1106 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
1107 }
1108 }
1109
1110 /**
1111 * @tc.number : VIDEO_MPEG4SWDEC_SURF_CHANGE_0300
1112 * @tc.name : surf model change in runing state
1113 * @tc.desc : function test
1114 */
1115 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0300, TestSize.Level2)
1116 {
1117 if (cap_mpeg4 != nullptr) {
1118 auto vDecSample = make_shared<VDecAPI11Sample>();
1119 vDecSample->INP_DIR = INP_DIR_1080_30;
1120 vDecSample->DEFAULT_WIDTH = 1920;
1121 vDecSample->DEFAULT_HEIGHT = 1080;
1122 vDecSample->DEFAULT_FRAME_RATE = 30;
1123 vDecSample->SURFACE_OUTPUT = false;
1124 vDecSample->autoSwitchSurface = false;
1125 vDecSample->CreateSurface();
1126 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
1127 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
1128 vDecSample->WaitForEOS();
1129 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1130 }
1131 }
1132
1133 /**
1134 * @tc.number : VIDEO_MPEG4SWDEC_SURF_CHANGE_0400
1135 * @tc.name : repeat call setSurface fastly
1136 * @tc.desc : function test
1137 */
1138 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_SURF_CHANGE_0400, TestSize.Level2)
1139 {
1140 if (cap_mpeg4 != nullptr) {
1141 auto vDecSample = make_shared<VDecAPI11Sample>();
1142 vDecSample->INP_DIR = INP_DIR_1080_30;
1143 vDecSample->DEFAULT_WIDTH = 1920;
1144 vDecSample->DEFAULT_HEIGHT = 1080;
1145 vDecSample->DEFAULT_FRAME_RATE = 30;
1146 vDecSample->SURFACE_OUTPUT = true;
1147 vDecSample->autoSwitchSurface = true;
1148 vDecSample->sleepOnFPS = true;
1149 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg4));
1150 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1151 vDecSample->WaitForEOS();
1152 }
1153 }
1154
1155 /**
1156 * @tc.number : VIDEO_SWDEC_RESOLUTION_PROFILE_0010
1157 * @tc.name : Resolution and profile change
1158 * @tc.desc : function test
1159 */
1160 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_SWDEC_RESOLUTION_PROFILE_0010, TestSize.Level2)
1161 {
1162 if (cap_mpeg4 != nullptr) {
1163 auto vDecSample = make_shared<VDecAPI11Sample>();
1164 vDecSample->INP_DIR = "/data/test/media/profResoChange.m4v";
1165 vDecSample->DEFAULT_WIDTH = 1920;
1166 vDecSample->DEFAULT_HEIGHT = 1080;
1167 vDecSample->DEFAULT_FRAME_RATE = 30;
1168 vDecSample->SURFACE_OUTPUT = false;
1169 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
1170 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1171 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1172 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1173 vDecSample->WaitForEOS();
1174 ASSERT_EQ(2110, vDecSample->outFrameCount);
1175 ASSERT_EQ(0, vDecSample->errCount);
1176 }
1177 }
1178
1179 /**
1180 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0010
1181 * @tc.name : mpeg4同步软解输出nv12
1182 * @tc.desc : function test
1183 */
1184 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0010, TestSize.Level1)
1185 {
1186 if (cap_mpeg4 != nullptr) {
1187 auto vDecSample = make_shared<VDecAPI11Sample>();
1188 vDecSample->INP_DIR = INP_DIR_1080_30;
1189 vDecSample->DEFAULT_WIDTH = 1920;
1190 vDecSample->DEFAULT_HEIGHT = 1080;
1191 vDecSample->DEFAULT_FRAME_RATE = 30;
1192 vDecSample->enbleSyncMode = 1;
1193 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1194 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
1195 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1196 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
1197 vDecSample->WaitForEOS();
1198 ASSERT_EQ(0, vDecSample->errCount);
1199 }
1200 }
1201
1202 /**
1203 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0020
1204 * @tc.name : mpeg4同步软解输出nv21
1205 * @tc.desc : function test
1206 */
1207 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0020, TestSize.Level0)
1208 {
1209 if (cap_mpeg4 != nullptr) {
1210 auto vDecSample = make_shared<VDecAPI11Sample>();
1211 vDecSample->INP_DIR = INP_DIR_1080_30;
1212 vDecSample->DEFAULT_WIDTH = 1920;
1213 vDecSample->DEFAULT_HEIGHT = 1080;
1214 vDecSample->DEFAULT_FRAME_RATE = 30;
1215 vDecSample->enbleSyncMode = 1;
1216 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
1217 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
1218 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1219 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
1220 vDecSample->WaitForEOS();
1221 ASSERT_EQ(0, vDecSample->errCount);
1222 }
1223 }
1224
1225 /**
1226 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0030
1227 * @tc.name : mpeg4同步软解输出surface
1228 * @tc.desc : function test
1229 */
1230 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0030, TestSize.Level1)
1231 {
1232 if (cap_mpeg4 != nullptr) {
1233 auto vDecSample = make_shared<VDecAPI11Sample>();
1234 vDecSample->INP_DIR = INP_DIR_1080_30;
1235 vDecSample->DEFAULT_WIDTH = 1920;
1236 vDecSample->DEFAULT_HEIGHT = 1080;
1237 vDecSample->DEFAULT_FRAME_RATE = 30;
1238 vDecSample->SURFACE_OUTPUT = true;
1239 vDecSample->enbleSyncMode = 1;
1240 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
1241 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1242 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1243 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
1244 vDecSample->WaitForEOS();
1245 ASSERT_EQ(0, vDecSample->errCount);
1246 }
1247 }
1248
1249 /**
1250 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0040
1251 * @tc.name : 264同步软解输出rgba
1252 * @tc.desc : function test
1253 */
1254 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG4_FUNC_0040, TestSize.Level1)
1255 {
1256 if (cap_mpeg4 != nullptr) {
1257 auto vDecSample = make_shared<VDecAPI11Sample>();
1258 vDecSample->INP_DIR = INP_DIR_1080_30;
1259 vDecSample->DEFAULT_WIDTH = 1920;
1260 vDecSample->DEFAULT_HEIGHT = 1080;
1261 vDecSample->DEFAULT_FRAME_RATE = 30;
1262 vDecSample->enbleSyncMode = 1;
1263 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_RGBA;
1264 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
1265 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1266 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
1267 vDecSample->WaitForEOS();
1268 ASSERT_EQ(0, vDecSample->errCount);
1269 }
1270 }
1271
1272 /**
1273 * @tc.number : VIDEO_MPEG4SWDEC_BLANK_FRAME_0010
1274 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder mpeg4
1275 * @tc.desc : function test
1276 */
1277 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_BLANK_FRAME_0010, TestSize.Level2)
1278 {
1279 if (cap_mpeg4 != nullptr) {
1280 auto vDecSample = make_shared<VDecAPI11Sample>();
1281 vDecSample->INP_DIR = INP_DIR_1080_30;
1282 vDecSample->DEFAULT_WIDTH = 1920;
1283 vDecSample->DEFAULT_HEIGHT = 1080;
1284 vDecSample->DEFAULT_FRAME_RATE = 30;
1285 vDecSample->enbleBlankFrame = 1;
1286 vDecSample->SF_OUTPUT = false;
1287 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg4));
1288 vDecSample->WaitForEOS();
1289 ASSERT_EQ(0, vDecSample->errCount);
1290 }
1291 }
1292
1293 /**
1294 * @tc.number : VIDEO_MPEG4SWDEC_BLANK_FRAME_0020
1295 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder mpeg4, surface
1296 * @tc.desc : function test
1297 */
1298 HWTEST_F(Mpeg4SwdecFuncNdkTest, VIDEO_MPEG4SWDEC_BLANK_FRAME_0020, TestSize.Level2)
1299 {
1300 if (cap_mpeg4 != nullptr) {
1301 auto vDecSample = make_shared<VDecAPI11Sample>();
1302 vDecSample->INP_DIR = INP_DIR_1080_30;
1303 vDecSample->DEFAULT_WIDTH = 1920;
1304 vDecSample->DEFAULT_HEIGHT = 1080;
1305 vDecSample->DEFAULT_FRAME_RATE = 30;
1306 vDecSample->enbleBlankFrame = 1;
1307 vDecSample->SF_OUTPUT = true;
1308 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg4));
1309 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1310 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1311 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1312 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1313 vDecSample->WaitForEOS();
1314 ASSERT_EQ(0, vDecSample->errCount);
1315 }
1316 }
1317 } // namespace