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 Mpeg2SwdecFuncNdkTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47 void InputFUNCTION();
48 void OutputFUNCTION();
49 void Release();
50 int32_t Stop();
51
52 protected:
53 const string CODEC_NAME = "avdec_mpeg2";
54 const char *INP_DIR_1 = "/data/test/media/simple@low_level_352_288_30.m2v";
55 const char *INP_DIR_2 = "/data/test/media/simple@main_level_640_480_30.m2v";
56 const char *INP_DIR_3 = "/data/test/media/main@low_level_352_288_30.m2v";
57 const char *INP_DIR_4 = "/data/test/media/main@main_level_640_480_30.m2v";
58 const char *INP_DIR_5 = "/data/test/media/main@high14_level_1280_720_60.m2v";
59 const char *INP_DIR_6 = "/data/test/media/main@high_level_1920_1080_60.m2v";
60 const char *INP_DIR_7 = "/data/test/media/snr_scalable@low_level_352_288_30.m2v";
61 const char *INP_DIR_8 = "/data/test/media/snr_scalable@main_level_640_480_30.m2v";
62 const char *INP_DIR_9 = "/data/test/media/snr_scalable@high_level_1920_1080_60.m2v";
63 const char *INP_DIR_10 = "/data/test/media/spatially_scalable@low_level_352_288_30.m2v";
64 const char *INP_DIR_11 = "/data/test/media/spatially_scalable@main_level_640_480_30.m2v";
65 const char *INP_DIR_12 = "/data/test/media/spatially_scalable@high14_level_1280_720_60.m2v";
66 const char *INP_DIR_13 = "/data/test/media/spatially_scalable@high_level_1920_1080_60.m2v";
67 const char *INP_DIR_14 = "/data/test/media/high@low_level_352_288_30.m2v";
68 const char *INP_DIR_15 = "/data/test/media/high@main_level_640_480_30.m2v";
69 const char *INP_DIR_16 = "/data/test/media/high@high14_level_1280_720_60.m2v";
70 const char *INP_DIR_17 = "/data/test/media/high@high_level_1920_1080_60.m2v";
71 const char *INP_DIR_18 = "/data/test/media/422P@main_level_640_480_30.m2v";
72 const char *INP_DIR_19 = "/data/test/media/422P@high14_level_1280_720_60.m2v";
73 const char *INP_DIR_20 = "/data/test/media/422P@high_level_1920_1080_60.m2v";
74 };
75 } // namespace Media
76 } // namespace OHOS
77
78 namespace {
79 static OH_AVCapability *cap_mpeg2 = nullptr;
80 static string g_codecNameMpeg2 = "";
81 } // namespace
82
SetUpTestCase()83 void Mpeg2SwdecFuncNdkTest::SetUpTestCase()
84 {
85 cap_mpeg2 = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG2, false, SOFTWARE);
86 g_codecNameMpeg2 = OH_AVCapability_GetName(cap_mpeg2);
87 cout << "g_codecNameMpeg2: " << g_codecNameMpeg2 << endl;
88 }
TearDownTestCase()89 void Mpeg2SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()90 void Mpeg2SwdecFuncNdkTest::SetUp() {}
TearDown()91 void Mpeg2SwdecFuncNdkTest::TearDown() {}
92
93 struct DecInfo {
94 const char *inpDir;
95 uint32_t defaultWidth;
96 uint32_t defaultHeight;
97 uint32_t defaultFrameRate;
98 };
99
RunDec(DecInfo decinfo)100 static void RunDec(DecInfo decinfo)
101 {
102 auto vDecSample = make_shared<VDecNdkSample>();
103 vDecSample->INP_DIR = decinfo.inpDir;
104 vDecSample->DEFAULT_WIDTH = decinfo.defaultWidth;
105 vDecSample->DEFAULT_HEIGHT = decinfo.defaultHeight;
106 vDecSample->DEFAULT_FRAME_RATE = decinfo.defaultFrameRate;
107 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
108 vDecSample->WaitForEOS();
109 }
110
111 namespace {
112 /**
113 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0100
114 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is NV12
115 * @tc.desc : FUNCTION test
116 */
117 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0100, TestSize.Level2)
118 {
119 if (cap_mpeg2 != nullptr) {
120 auto vDecSample = make_shared<VDecNdkSample>();
121 vDecSample->INP_DIR = INP_DIR_2;
122 vDecSample->DEFAULT_WIDTH = 640;
123 vDecSample->DEFAULT_HEIGHT = 480;
124 vDecSample->DEFAULT_FRAME_RATE = 30;
125 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
126 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
127 vDecSample->WaitForEOS();
128 ASSERT_EQ(0, vDecSample->errCount);
129 }
130 }
131
132 /**
133 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0200
134 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is NV21
135 * @tc.desc : FUNCTION test
136 */
137 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0200, TestSize.Level2)
138 {
139 if (cap_mpeg2 != nullptr) {
140 auto vDecSample = make_shared<VDecNdkSample>();
141 vDecSample->INP_DIR = INP_DIR_2;
142 vDecSample->DEFAULT_WIDTH = 640;
143 vDecSample->DEFAULT_HEIGHT = 480;
144 vDecSample->DEFAULT_FRAME_RATE = 30;
145 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
146 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
147 vDecSample->WaitForEOS();
148 ASSERT_EQ(0, vDecSample->errCount);
149 }
150 }
151
152 /**
153 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0300
154 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is YUV420
155 * @tc.desc : FUNCTION test
156 */
157 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0300, TestSize.Level2)
158 {
159 if (cap_mpeg2 != nullptr) {
160 auto vDecSample = make_shared<VDecNdkSample>();
161 vDecSample->INP_DIR = INP_DIR_2;
162 vDecSample->DEFAULT_WIDTH = 640;
163 vDecSample->DEFAULT_HEIGHT = 480;
164 vDecSample->DEFAULT_FRAME_RATE = 30;
165 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
166 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
167 vDecSample->WaitForEOS();
168 ASSERT_EQ(0, vDecSample->errCount);
169 }
170 }
171
172 /**
173 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0400
174 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is RGBa
175 * @tc.desc : FUNCTION test
176 */
177 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0400, TestSize.Level2)
178 {
179 if (cap_mpeg2 != nullptr) {
180 auto vDecSample = make_shared<VDecNdkSample>();
181 vDecSample->INP_DIR = INP_DIR_2;
182 vDecSample->DEFAULT_WIDTH = 640;
183 vDecSample->DEFAULT_HEIGHT = 480;
184 vDecSample->DEFAULT_FRAME_RATE = 30;
185 vDecSample->checkOutPut = false;
186 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
187 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
188 vDecSample->WaitForEOS();
189 ASSERT_EQ(0, vDecSample->errCount);
190 }
191 }
192
193 /**
194 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0500
195 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is NV12
196 * @tc.desc : FUNCTION test
197 */
198 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0500, TestSize.Level2)
199 {
200 if (cap_mpeg2 != nullptr) {
201 auto vDecSample = make_shared<VDecNdkSample>();
202 vDecSample->INP_DIR = INP_DIR_2;
203 vDecSample->DEFAULT_WIDTH = 640;
204 vDecSample->DEFAULT_HEIGHT = 480;
205 vDecSample->DEFAULT_FRAME_RATE = 30;
206 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
207 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
208 vDecSample->WaitForEOS();
209 bool isVaild = false;
210 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
211 ASSERT_EQ(false, isVaild);
212 ASSERT_EQ(0, vDecSample->errCount);
213 }
214 }
215
216 /**
217 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0600
218 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is NV21
219 * @tc.desc : FUNCTION test
220 */
221 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0600, TestSize.Level2)
222 {
223 if (cap_mpeg2 != nullptr) {
224 auto vDecSample = make_shared<VDecNdkSample>();
225 vDecSample->INP_DIR = INP_DIR_2;
226 vDecSample->DEFAULT_WIDTH = 640;
227 vDecSample->DEFAULT_HEIGHT = 480;
228 vDecSample->DEFAULT_FRAME_RATE = 30;
229 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
230 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
231 vDecSample->WaitForEOS();
232 bool isVaild = false;
233 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
234 ASSERT_EQ(false, isVaild);
235 ASSERT_EQ(0, vDecSample->errCount);
236 }
237 }
238
239 /**
240 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0700
241 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is YUV420
242 * @tc.desc : FUNCTION test
243 */
244 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0700, TestSize.Level2)
245 {
246 if (cap_mpeg2 != nullptr) {
247 auto vDecSample = make_shared<VDecNdkSample>();
248 vDecSample->INP_DIR = INP_DIR_2;
249 vDecSample->DEFAULT_WIDTH = 640;
250 vDecSample->DEFAULT_HEIGHT = 480;
251 vDecSample->DEFAULT_FRAME_RATE = 30;
252 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
253 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
254 vDecSample->WaitForEOS();
255 bool isVaild = false;
256 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
257 ASSERT_EQ(false, isVaild);
258 ASSERT_EQ(0, vDecSample->errCount);
259 }
260 }
261
262 /**
263 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0800
264 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is RGBa
265 * @tc.desc : FUNCTION test
266 */
267 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0800, TestSize.Level2)
268 {
269 if (cap_mpeg2 != nullptr) {
270 auto vDecSample = make_shared<VDecNdkSample>();
271 vDecSample->INP_DIR = INP_DIR_2;
272 vDecSample->DEFAULT_WIDTH = 640;
273 vDecSample->DEFAULT_HEIGHT = 480;
274 vDecSample->DEFAULT_FRAME_RATE = 30;
275 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
276 vDecSample->checkOutPut = false;
277 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
278 vDecSample->WaitForEOS();
279 bool isVaild = false;
280 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
281 ASSERT_EQ(false, isVaild);
282 ASSERT_EQ(0, vDecSample->errCount);
283 }
284 }
285
286 /**
287 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0900
288 * @tc.name : decode mpeg2 stream ,under buffer mode
289 * @tc.desc : FUNCTION test
290 */
291 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0900, TestSize.Level2)
292 {
293 if (cap_mpeg2 != nullptr) {
294 DecInfo fileTest1{INP_DIR_1, 352, 288, 30};
295 RunDec(fileTest1);
296 DecInfo fileTest2{INP_DIR_2, 640, 480, 30};
297 RunDec(fileTest2);
298 DecInfo fileTest3{INP_DIR_3, 352, 288, 30};
299 RunDec(fileTest3);
300 DecInfo fileTest4{INP_DIR_4, 640, 480, 30};
301 RunDec(fileTest4);
302 DecInfo fileTest5{INP_DIR_5, 1280, 720, 60};
303 RunDec(fileTest5);
304 DecInfo fileTest6{INP_DIR_6, 1920, 1080, 60};
305 RunDec(fileTest6);
306 DecInfo fileTest7{INP_DIR_7, 352, 288, 30};
307 RunDec(fileTest7);
308 DecInfo fileTest8{INP_DIR_8, 640, 480, 30};
309 RunDec(fileTest8);
310 DecInfo fileTest9{INP_DIR_9, 1920, 1080, 60};
311 RunDec(fileTest9);
312 DecInfo fileTest10{INP_DIR_10, 352, 288, 30};
313 RunDec(fileTest10);
314 DecInfo fileTest11{INP_DIR_11, 640, 480, 30};
315 RunDec(fileTest11);
316 DecInfo fileTest12{INP_DIR_12, 1280, 720, 60};
317 RunDec(fileTest12);
318 DecInfo fileTest13{INP_DIR_13, 1920, 1080, 60};
319 RunDec(fileTest13);
320 DecInfo fileTest14{INP_DIR_14, 352, 288, 30};
321 RunDec(fileTest14);
322 DecInfo fileTest15{INP_DIR_15, 640, 480, 30};
323 RunDec(fileTest15);
324 DecInfo fileTest16{INP_DIR_16, 1280, 720, 60};
325 RunDec(fileTest16);
326 DecInfo fileTest17{INP_DIR_17, 1920, 1080, 60};
327 RunDec(fileTest17);
328 DecInfo fileTest18{INP_DIR_18, 640, 480, 30};
329 RunDec(fileTest18);
330 DecInfo fileTest19{INP_DIR_19, 1280, 720, 60};
331 RunDec(fileTest19);
332 DecInfo fileTest20{INP_DIR_20, 1920, 1080, 60};
333 RunDec(fileTest20);
334 }
335 }
336
337 /**
338 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1000
339 * @tc.name : odd resolution of 641 * 481
340 * @tc.desc : FUNCTION test
341 */
342 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1000, TestSize.Level2)
343 {
344 if (cap_mpeg2 != nullptr) {
345 auto vDecSample = make_shared<VDecNdkSample>();
346 vDecSample->INP_DIR = "/data/test/media/simple@main_level_641_481_30.m2v";
347 vDecSample->DEFAULT_WIDTH = 641;
348 vDecSample->DEFAULT_HEIGHT = 481;
349 vDecSample->DEFAULT_FRAME_RATE = 30;
350 vDecSample->SURFACE_OUTPUT = false;
351 vDecSample->checkOutPut = false;
352 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
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(0, vDecSample->errCount);
358 }
359 }
360
361 /**
362 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1100
363 * @tc.name : odd resolution of 1281 * 721
364 * @tc.desc : FUNCTION test
365 */
366 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1100, TestSize.Level2)
367 {
368 if (cap_mpeg2 != nullptr) {
369 auto vDecSample = make_shared<VDecNdkSample>();
370 vDecSample->INP_DIR = "/data/test/media/main@high14_level_1281_721_60.m2v";
371 vDecSample->DEFAULT_WIDTH = 1281;
372 vDecSample->DEFAULT_HEIGHT = 721;
373 vDecSample->DEFAULT_FRAME_RATE = 60;
374 vDecSample->SURFACE_OUTPUT = false;
375 vDecSample->checkOutPut = false;
376 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
377 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
378 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
379 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
380 vDecSample->WaitForEOS();
381 ASSERT_EQ(0, vDecSample->errCount);
382 }
383 }
384
385 /**
386 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1200
387 * @tc.name : mpeg2 decode res change video
388 * @tc.desc : FUNCTION test
389 */
390 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1200, TestSize.Level2)
391 {
392 if (cap_mpeg2 != nullptr) {
393 auto vDecSample = make_shared<VDecNdkSample>();
394 vDecSample->INP_DIR = "/data/test/media/mpeg2_res_change.m2v";
395 vDecSample->DEFAULT_WIDTH = 1920;
396 vDecSample->DEFAULT_HEIGHT = 1080;
397 vDecSample->DEFAULT_FRAME_RATE = 30;
398 vDecSample->SURFACE_OUTPUT = false;
399 vDecSample->checkOutPut = false;
400 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
401 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
402 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
403 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
404 vDecSample->WaitForEOS();
405 ASSERT_EQ(0, vDecSample->errCount);
406 }
407 }
408
409 /**
410 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1300
411 * @tc.name : rotation is 90
412 * @tc.desc : FUNCTION test
413 */
414 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1300, TestSize.Level2)
415 {
416 if (cap_mpeg2 != nullptr) {
417 auto vDecSample = make_shared<VDecNdkSample>();
418 vDecSample->INP_DIR = "/data/test/media/simple@low_level_352_288_30_rotation_90.m2v";
419 vDecSample->DEFAULT_WIDTH = 352;
420 vDecSample->DEFAULT_HEIGHT = 288;
421 vDecSample->DEFAULT_FRAME_RATE = 30;
422 vDecSample->DEFAULT_ROTATION = 90;
423 vDecSample->SURFACE_OUTPUT = false;
424 vDecSample->checkOutPut = false;
425 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
426 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
427 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
428 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
429 vDecSample->WaitForEOS();
430 ASSERT_EQ(0, vDecSample->errCount);
431 }
432 }
433
434 /**
435 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1400
436 * @tc.name : rotation is 180
437 * @tc.desc : FUNCTION test
438 */
439 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1400, TestSize.Level2)
440 {
441 if (cap_mpeg2 != nullptr) {
442 auto vDecSample = make_shared<VDecNdkSample>();
443 vDecSample->INP_DIR = "/data/test/media/simple@low_level_352_288_30_rotation_180.m2v";
444 vDecSample->DEFAULT_WIDTH = 352;
445 vDecSample->DEFAULT_HEIGHT = 288;
446 vDecSample->DEFAULT_FRAME_RATE = 30;
447 vDecSample->DEFAULT_ROTATION = 180;
448 vDecSample->SURFACE_OUTPUT = false;
449 vDecSample->checkOutPut = false;
450 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
451 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
452 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
453 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
454 vDecSample->WaitForEOS();
455 ASSERT_EQ(0, vDecSample->errCount);
456 }
457 }
458
459 /**
460 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1500
461 * @tc.name : rotation is 270
462 * @tc.desc : FUNCTION test
463 */
464 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1500, TestSize.Level2)
465 {
466 if (cap_mpeg2 != nullptr) {
467 auto vDecSample = make_shared<VDecNdkSample>();
468 vDecSample->INP_DIR = "/data/test/media/simple@low_level_352_288_30_rotation_270.m2v";
469 vDecSample->DEFAULT_WIDTH = 352;
470 vDecSample->DEFAULT_HEIGHT = 288;
471 vDecSample->DEFAULT_FRAME_RATE = 30;
472 vDecSample->DEFAULT_ROTATION = 270;
473 vDecSample->SURFACE_OUTPUT = false;
474 vDecSample->checkOutPut = false;
475 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
476 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
477 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
478 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
479 vDecSample->WaitForEOS();
480 ASSERT_EQ(0, vDecSample->errCount);
481 }
482 }
483
484 /**
485 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1600
486 * @tc.name : unaligned byte test
487 * @tc.desc : FUNCTION test
488 */
489 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1600, TestSize.Level2)
490 {
491 if (cap_mpeg2 != nullptr) {
492 auto vDecSample = make_shared<VDecNdkSample>();
493 vDecSample->INP_DIR = "/data/test/media/simple@low_level_353_289_30.m2v";
494 vDecSample->DEFAULT_WIDTH = 353;
495 vDecSample->DEFAULT_HEIGHT = 289;
496 vDecSample->DEFAULT_FRAME_RATE = 30;
497 vDecSample->SURFACE_OUTPUT = false;
498 vDecSample->checkOutPut = false;
499 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
500 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
501 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
502 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
503 vDecSample->WaitForEOS();
504 ASSERT_EQ(0, vDecSample->errCount);
505 }
506 }
507
508 /**
509 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1700
510 * @tc.name : mpeg2 decode err resolution
511 * @tc.desc : FUNCTION test
512 */
513 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1700, TestSize.Level2)
514 {
515 if (cap_mpeg2 != nullptr) {
516 auto vDecSample = make_shared<VDecNdkSample>();
517 vDecSample->INP_DIR = "/data/test/media/mpeg2_err_res.m2v";
518 vDecSample->DEFAULT_WIDTH = 1920;
519 vDecSample->DEFAULT_HEIGHT = 1080;
520 vDecSample->DEFAULT_FRAME_RATE = 30;
521 vDecSample->SURFACE_OUTPUT = false;
522 vDecSample->checkOutPut = false;
523 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
524 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
525 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
526 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
527 vDecSample->WaitForEOS();
528 ASSERT_EQ(0, vDecSample->errCount);
529 }
530 }
531
532 /**
533 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0100
534 * @tc.name : 1080p ,surf model change in normal state
535 * @tc.desc : FUNCTION test
536 */
537 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0100, TestSize.Level2)
538 {
539 if (cap_mpeg2 != nullptr) {
540 auto vDecSample = make_shared<VDecAPI11Sample>();
541 vDecSample->INP_DIR = INP_DIR_6;
542 vDecSample->DEFAULT_WIDTH = 1920;
543 vDecSample->DEFAULT_HEIGHT = 1080;
544 vDecSample->DEFAULT_FRAME_RATE = 60;
545 vDecSample->SURFACE_OUTPUT = true;
546 vDecSample->autoSwitchSurface = true;
547 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
548 vDecSample->sleepOnFPS = true;
549 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
550 vDecSample->WaitForEOS();
551 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
552 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
553 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
554 }
555 }
556
557 /**
558 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0200
559 * @tc.name : 1080p ,surf model change in flushed state
560 * @tc.desc : FUNCTION test
561 */
562 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0200, TestSize.Level2)
563 {
564 if (cap_mpeg2 != nullptr) {
565 auto vDecSample = make_shared<VDecAPI11Sample>();
566 vDecSample->INP_DIR = INP_DIR_6;
567 vDecSample->DEFAULT_WIDTH = 1920;
568 vDecSample->DEFAULT_HEIGHT = 1080;
569 vDecSample->DEFAULT_FRAME_RATE = 60;
570 vDecSample->SURFACE_OUTPUT = true;
571 vDecSample->autoSwitchSurface = true;
572 vDecSample->sleepOnFPS = true;
573 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
574 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
575 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
576 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
577 }
578 }
579
580 /**
581 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0300
582 * @tc.name : 1080p ,surf model change in runing state
583 * @tc.desc : FUNCTION test
584 */
585 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0300, TestSize.Level2)
586 {
587 if (cap_mpeg2 != nullptr) {
588 auto vDecSample = make_shared<VDecAPI11Sample>();
589 vDecSample->INP_DIR = INP_DIR_6;
590 vDecSample->DEFAULT_WIDTH = 1920;
591 vDecSample->DEFAULT_HEIGHT = 1080;
592 vDecSample->DEFAULT_FRAME_RATE = 60;
593 vDecSample->SURFACE_OUTPUT = false;
594 vDecSample->autoSwitchSurface = false;
595 vDecSample->CreateSurface();
596 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
597 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
598 vDecSample->WaitForEOS();
599 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
600 }
601 }
602
603 /**
604 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0400
605 * @tc.name : 1080p ,repeat call setSurface fastly
606 * @tc.desc : FUNCTION test
607 */
608 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0400, TestSize.Level2)
609 {
610 if (cap_mpeg2 != nullptr) {
611 auto vDecSample = make_shared<VDecAPI11Sample>();
612 vDecSample->INP_DIR = INP_DIR_6;
613 vDecSample->DEFAULT_WIDTH = 1920;
614 vDecSample->DEFAULT_HEIGHT = 1080;
615 vDecSample->DEFAULT_FRAME_RATE = 60;
616 vDecSample->SURFACE_OUTPUT = true;
617 vDecSample->autoSwitchSurface = true;
618 vDecSample->sleepOnFPS = true;
619 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
620 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
621 vDecSample->WaitForEOS();
622 }
623 }
624
625 /**
626 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0500
627 * @tc.name : 1080p ,surf model change in flush to runnig state
628 * @tc.desc : FUNCTION test
629 */
630 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0500, TestSize.Level2)
631 {
632 if (cap_mpeg2 != nullptr) {
633 auto vDecSample = make_shared<VDecAPI11Sample>();
634 vDecSample->INP_DIR = INP_DIR_6;
635 vDecSample->DEFAULT_WIDTH = 1920;
636 vDecSample->DEFAULT_HEIGHT = 1080;
637 vDecSample->DEFAULT_FRAME_RATE = 60;
638 vDecSample->SURFACE_OUTPUT = true;
639 vDecSample->autoSwitchSurface = true;
640 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
641 vDecSample->sleepOnFPS = true;
642 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
643 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
644 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
645 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
646 }
647 }
648
649 /**
650 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0600
651 * @tc.name : 1080p ,surf model change in decoder finish to End-of-Stream state
652 * @tc.desc : FUNCTION test
653 */
654 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0600, TestSize.Level2)
655 {
656 if (cap_mpeg2 != nullptr) {
657 auto vDecSample = make_shared<VDecAPI11Sample>();
658 vDecSample->INP_DIR = INP_DIR_6;
659 vDecSample->DEFAULT_WIDTH = 1920;
660 vDecSample->DEFAULT_HEIGHT = 1080;
661 vDecSample->DEFAULT_FRAME_RATE = 60;
662 vDecSample->autoSwitchSurface = true;
663 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
664 vDecSample->sleepOnFPS = true;
665 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
666 vDecSample->WaitForEOS();
667 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
668 }
669 }
670
671 /**
672 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0700
673 * @tc.name : 1080p ,surf model change in config state
674 * @tc.desc : FUNCTION test
675 */
676 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0700, TestSize.Level2)
677 {
678 if (cap_mpeg2 != nullptr) {
679 auto vDecSample = make_shared<VDecAPI11Sample>();
680 vDecSample->INP_DIR = INP_DIR_6;
681 vDecSample->DEFAULT_WIDTH = 1920;
682 vDecSample->DEFAULT_HEIGHT = 1080;
683 vDecSample->DEFAULT_FRAME_RATE = 60;
684 vDecSample->SURFACE_OUTPUT = false;
685 vDecSample->autoSwitchSurface = false;
686 vDecSample->CreateSurface();
687 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
688 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
689 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
690 vDecSample->WaitForEOS();
691 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
692 }
693 }
694
695 /**
696 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0800
697 * @tc.name : Two object repeat call setSurface fastly
698 * @tc.desc : FUNCTION test
699 */
700 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0800, TestSize.Level2)
701 {
702 if (cap_mpeg2 != nullptr) {
703 auto vDecSample = make_shared<VDecAPI11Sample>();
704 vDecSample->INP_DIR = INP_DIR_6;
705 vDecSample->DEFAULT_WIDTH = 1920;
706 vDecSample->DEFAULT_HEIGHT = 1080;
707 vDecSample->DEFAULT_FRAME_RATE = 60;
708 vDecSample->autoSwitchSurface = true;
709 vDecSample->sleepOnFPS = true;
710 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
711 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
712 vDecSample->WaitForEOS();
713 auto vDecSample_1 = make_shared<VDecAPI11Sample>();
714 vDecSample_1->INP_DIR = INP_DIR_6;
715 vDecSample_1->DEFAULT_WIDTH = 1920;
716 vDecSample_1->DEFAULT_HEIGHT = 1080;
717 vDecSample_1->DEFAULT_FRAME_RATE = 60;
718 vDecSample_1->autoSwitchSurface = true;
719 vDecSample_1->sleepOnFPS = true;
720 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RunVideoDec_Surface(g_codecNameMpeg2));
721 ASSERT_EQ(AV_ERR_OK, vDecSample_1->SwitchSurface());
722 vDecSample_1->WaitForEOS();
723 }
724 }
725
726 /**
727 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0900
728 * @tc.name : repeat call setSurface fastly 2 time
729 * @tc.desc : FUNCTION test
730 */
731 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0900, TestSize.Level2)
732 {
733 if (cap_mpeg2 != nullptr) {
734 for (int i = 0; i < 2; i++) {
735 auto vDecSample = make_shared<VDecAPI11Sample>();
736 vDecSample->INP_DIR = INP_DIR_6;
737 vDecSample->DEFAULT_WIDTH = 1920;
738 vDecSample->DEFAULT_HEIGHT = 1080;
739 vDecSample->DEFAULT_FRAME_RATE = 60;
740 vDecSample->autoSwitchSurface = true;
741 vDecSample->sleepOnFPS = true;
742 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
743 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
744 vDecSample->WaitForEOS();
745 }
746 }
747 }
748
749 /**
750 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0100
751 * @tc.name : width is -1 ,height is -1
752 * @tc.desc : FUNCTION test
753 */
754 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0100, TestSize.Level2)
755 {
756 if (cap_mpeg2 != nullptr) {
757 auto vDecSample = make_shared<VDecNdkSample>();
758 vDecSample->INP_DIR = INP_DIR_2;
759 vDecSample->DEFAULT_WIDTH = -1;
760 vDecSample->DEFAULT_HEIGHT = -1;
761 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
762 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
763 ASSERT_EQ(0, vDecSample->errCount);
764 }
765 }
766
767 /**
768 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0200
769 * @tc.name : width is 0 ,height is 0
770 * @tc.desc : FUNCTION test
771 */
772 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0200, TestSize.Level2)
773 {
774 if (cap_mpeg2 != nullptr) {
775 auto vDecSample = make_shared<VDecNdkSample>();
776 vDecSample->INP_DIR = INP_DIR_2;
777 vDecSample->DEFAULT_WIDTH = 0;
778 vDecSample->DEFAULT_HEIGHT = 0;
779 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
780 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
781 ASSERT_EQ(0, vDecSample->errCount);
782 }
783 }
784
785 /**
786 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0300
787 * @tc.name : width is 1 ,height is 1
788 * @tc.desc : FUNCTION test
789 */
790 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0300, TestSize.Level2)
791 {
792 if (cap_mpeg2 != nullptr) {
793 auto vDecSample = make_shared<VDecNdkSample>();
794 vDecSample->INP_DIR = INP_DIR_2;
795 vDecSample->DEFAULT_WIDTH = 1;
796 vDecSample->DEFAULT_HEIGHT = 1;
797 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
798 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
799 ASSERT_EQ(0, vDecSample->errCount);
800 }
801 }
802
803 /**
804 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0400
805 * @tc.name : width is 1920 ,height is 1080
806 * @tc.desc : FUNCTION test
807 */
808 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0400, TestSize.Level2)
809 {
810 if (cap_mpeg2 != nullptr) {
811 auto vDecSample = make_shared<VDecNdkSample>();
812 vDecSample->INP_DIR = INP_DIR_2;
813 vDecSample->DEFAULT_WIDTH = 1920;
814 vDecSample->DEFAULT_HEIGHT = 1080;
815 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
816 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
817 ASSERT_EQ(0, vDecSample->errCount);
818 }
819 }
820
821 /**
822 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0500
823 * @tc.name : width is 4097 ,height is 4097
824 * @tc.desc : FUNCTION test
825 */
826 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0500, TestSize.Level2)
827 {
828 if (cap_mpeg2 != nullptr) {
829 auto vDecSample = make_shared<VDecNdkSample>();
830 vDecSample->INP_DIR = INP_DIR_2;
831 vDecSample->DEFAULT_WIDTH = 4097;
832 vDecSample->DEFAULT_HEIGHT = 4097;
833 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
834 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
835 ASSERT_EQ(0, vDecSample->errCount);
836 }
837 }
838
839 /**
840 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0600
841 * @tc.name : width is 10000 ,height is 10000
842 * @tc.desc : FUNCTION test
843 */
844 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0600, TestSize.Level2)
845 {
846 if (cap_mpeg2 != nullptr) {
847 auto vDecSample = make_shared<VDecNdkSample>();
848 vDecSample->INP_DIR = INP_DIR_2;
849 vDecSample->DEFAULT_WIDTH = 10000;
850 vDecSample->DEFAULT_HEIGHT = 10000;
851 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
852 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
853 ASSERT_EQ(0, vDecSample->errCount);
854 }
855 }
856
857 /**
858 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0700
859 * @tc.name : framerate is -1
860 * @tc.desc : FUNCTION test
861 */
862 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0700, TestSize.Level2)
863 {
864 if (cap_mpeg2 != nullptr) {
865 auto vDecSample = make_shared<VDecNdkSample>();
866 vDecSample->INP_DIR = INP_DIR_2;
867 vDecSample->DEFAULT_WIDTH = 640;
868 vDecSample->DEFAULT_HEIGHT = 480;
869 vDecSample->DEFAULT_FRAME_RATE = -1;
870 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
871 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
872 ASSERT_EQ(0, vDecSample->errCount);
873 }
874 }
875
876 /**
877 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0800
878 * @tc.name : framerate is 0
879 * @tc.desc : FUNCTION test
880 */
881 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0800, TestSize.Level2)
882 {
883 if (cap_mpeg2 != nullptr) {
884 auto vDecSample = make_shared<VDecNdkSample>();
885 vDecSample->INP_DIR = INP_DIR_2;
886 vDecSample->DEFAULT_WIDTH = 640;
887 vDecSample->DEFAULT_HEIGHT = 480;
888 vDecSample->DEFAULT_FRAME_RATE = 0;
889 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
890 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
891 ASSERT_EQ(0, vDecSample->errCount);
892 }
893 }
894
895 /**
896 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0900
897 * @tc.name : framerate is 10000
898 * @tc.desc : FUNCTION test
899 */
900 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0900, TestSize.Level2)
901 {
902 if (cap_mpeg2 != nullptr) {
903 auto vDecSample = make_shared<VDecNdkSample>();
904 vDecSample->INP_DIR = INP_DIR_2;
905 vDecSample->DEFAULT_WIDTH = 640;
906 vDecSample->DEFAULT_HEIGHT = 480;
907 vDecSample->DEFAULT_FRAME_RATE = 10000;
908 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
909 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
910 vDecSample->WaitForEOS();
911 ASSERT_EQ(0, vDecSample->errCount);
912 }
913 }
914
915 /**
916 * @tc.number : VIDEO_MPEG2VIDEO_PARA_1000
917 * @tc.name : MPEG2 decoder, MPEG4 input
918 * @tc.desc : FUNCTION test
919 */
920 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_1000, TestSize.Level2)
921 {
922 if (cap_mpeg2 != nullptr) {
923 auto vDecSample = make_shared<VDecNdkSample>();
924 vDecSample->INP_DIR = "/data/test/media/mpeg4.m4v";
925 vDecSample->DEFAULT_WIDTH = 1280;
926 vDecSample->DEFAULT_HEIGHT = 720;
927 vDecSample->DEFAULT_FRAME_RATE = 30;
928 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
929 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
930 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
931 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
932 vDecSample->WaitForEOS();
933 ASSERT_EQ(0, vDecSample->errCount);
934 }
935 }
936
937 /**
938 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0010
939 * @tc.name : mpeg2同步软解输出nv12
940 * @tc.desc : function test
941 */
942 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0010, TestSize.Level1)
943 {
944 if (cap_mpeg2 != nullptr) {
945 auto vDecSample = make_shared<VDecAPI11Sample>();
946 vDecSample->INP_DIR = INP_DIR_6;
947 vDecSample->DEFAULT_WIDTH = 1920;
948 vDecSample->DEFAULT_HEIGHT = 1080;
949 vDecSample->DEFAULT_FRAME_RATE = 30;
950 vDecSample->enbleSyncMode = 1;
951 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
952 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
953 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
954 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
955 vDecSample->WaitForEOS();
956 ASSERT_EQ(0, vDecSample->errCount);
957 }
958 }
959
960 /**
961 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0020
962 * @tc.name : mpeg2同步软解输出nv21
963 * @tc.desc : function test
964 */
965 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0020, TestSize.Level0)
966 {
967 if (cap_mpeg2 != nullptr) {
968 auto vDecSample = make_shared<VDecAPI11Sample>();
969 vDecSample->INP_DIR = INP_DIR_6;
970 vDecSample->DEFAULT_WIDTH = 1920;
971 vDecSample->DEFAULT_HEIGHT = 1080;
972 vDecSample->DEFAULT_FRAME_RATE = 30;
973 vDecSample->enbleSyncMode = 1;
974 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
975 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
976 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
977 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
978 vDecSample->WaitForEOS();
979 ASSERT_EQ(0, vDecSample->errCount);
980 }
981 }
982
983 /**
984 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0030
985 * @tc.name : mpeg2同步软解输出surface
986 * @tc.desc : function test
987 */
988 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0030, TestSize.Level1)
989 {
990 if (cap_mpeg2 != nullptr) {
991 auto vDecSample = make_shared<VDecAPI11Sample>();
992 vDecSample->INP_DIR = INP_DIR_6;
993 vDecSample->DEFAULT_WIDTH = 1920;
994 vDecSample->DEFAULT_HEIGHT = 1080;
995 vDecSample->DEFAULT_FRAME_RATE = 30;
996 vDecSample->SURFACE_OUTPUT = true;
997 vDecSample->enbleSyncMode = 1;
998 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
999 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1000 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1001 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
1002 vDecSample->WaitForEOS();
1003 ASSERT_EQ(0, vDecSample->errCount);
1004 }
1005 }
1006
1007 /**
1008 * @tc.number : VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0040
1009 * @tc.name : 264同步软解输出rgba
1010 * @tc.desc : function test
1011 */
1012 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SWMPEG2_FUNC_0040, TestSize.Level1)
1013 {
1014 if (cap_mpeg2 != nullptr) {
1015 auto vDecSample = make_shared<VDecAPI11Sample>();
1016 vDecSample->INP_DIR = INP_DIR_6;
1017 vDecSample->DEFAULT_WIDTH = 1920;
1018 vDecSample->DEFAULT_HEIGHT = 1080;
1019 vDecSample->DEFAULT_FRAME_RATE = 30;
1020 vDecSample->enbleSyncMode = 1;
1021 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_RGBA;
1022 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
1023 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1024 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
1025 vDecSample->WaitForEOS();
1026 ASSERT_EQ(0, vDecSample->errCount);
1027 }
1028 }
1029
1030 /**
1031 * @tc.number : VIDEO_DECODE_BLANK_FRAME_0010
1032 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder mpeg2
1033 * @tc.desc : function test
1034 */
1035 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_DECODE_BLANK_FRAME_0010, TestSize.Level2)
1036 {
1037 if (cap_mpeg2 != nullptr) {
1038 auto vDecSample = make_shared<VDecAPI11Sample>();
1039 vDecSample->INP_DIR = INP_DIR_6;
1040 vDecSample->DEFAULT_WIDTH = 1920;
1041 vDecSample->DEFAULT_HEIGHT = 1080;
1042 vDecSample->DEFAULT_FRAME_RATE = 30;
1043 vDecSample->enbleBlankFrame = 1;
1044 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
1045 vDecSample->WaitForEOS();
1046 ASSERT_EQ(0, vDecSample->errCount);
1047 }
1048 }
1049
1050 /**
1051 * @tc.number : VIDEO_DECODE_BLANK_FRAME_0020
1052 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder mpeg2，surface
1053 * @tc.desc : function test
1054 */
1055 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_DECODE_BLANK_FRAME_0020, TestSize.Level2)
1056 {
1057 if (cap_mpeg2 != nullptr) {
1058 auto vDecSample = make_shared<VDecAPI11Sample>();
1059 vDecSample->INP_DIR = INP_DIR_6;
1060 vDecSample->DEFAULT_WIDTH = 1920;
1061 vDecSample->DEFAULT_HEIGHT = 1080;
1062 vDecSample->DEFAULT_FRAME_RATE = 30;
1063 vDecSample->enbleBlankFrame = 1;
1064 vDecSample->SURFACE_OUTPUT = true;
1065 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
1066 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1067 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1068 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1069 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1070 vDecSample->WaitForEOS();
1071 ASSERT_EQ(0, vDecSample->errCount);
1072 }
1073 }
1074 }