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 }
89
TearDownTestCase()90 void Mpeg2SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()91 void Mpeg2SwdecFuncNdkTest::SetUp() {}
TearDown()92 void Mpeg2SwdecFuncNdkTest::TearDown() {}
93
94 struct DecInfo {
95 const char *inpDir;
96 uint32_t defaultWidth;
97 uint32_t defaultHeight;
98 uint32_t defaultFrameRate;
99 };
100
RunDec(DecInfo decinfo)101 static void RunDec(DecInfo decinfo)
102 {
103 auto vDecSample = make_shared<VDecNdkSample>();
104 vDecSample->INP_DIR = decinfo.inpDir;
105 vDecSample->DEFAULT_WIDTH = decinfo.defaultWidth;
106 vDecSample->DEFAULT_HEIGHT = decinfo.defaultHeight;
107 vDecSample->DEFAULT_FRAME_RATE = decinfo.defaultFrameRate;
108 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
109 vDecSample->WaitForEOS();
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 auto vDecSample = make_shared<VDecNdkSample>();
120 vDecSample->INP_DIR = INP_DIR_2;
121 vDecSample->DEFAULT_WIDTH = 640;
122 vDecSample->DEFAULT_HEIGHT = 480;
123 vDecSample->DEFAULT_FRAME_RATE = 30;
124 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
125 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
126 vDecSample->WaitForEOS();
127 ASSERT_EQ(0, vDecSample->errCount);
128 }
129
130 /**
131 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0200
132 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is NV21
133 * @tc.desc : FUNCTION test
134 */
135 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0200, TestSize.Level2)
136 {
137 auto vDecSample = make_shared<VDecNdkSample>();
138 vDecSample->INP_DIR = INP_DIR_2;
139 vDecSample->DEFAULT_WIDTH = 640;
140 vDecSample->DEFAULT_HEIGHT = 480;
141 vDecSample->DEFAULT_FRAME_RATE = 30;
142 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
143 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
144 vDecSample->WaitForEOS();
145 ASSERT_EQ(0, vDecSample->errCount);
146 }
147
148 /**
149 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0300
150 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is YUV420
151 * @tc.desc : FUNCTION test
152 */
153 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0300, TestSize.Level2)
154 {
155 auto vDecSample = make_shared<VDecNdkSample>();
156 vDecSample->INP_DIR = INP_DIR_2;
157 vDecSample->DEFAULT_WIDTH = 640;
158 vDecSample->DEFAULT_HEIGHT = 480;
159 vDecSample->DEFAULT_FRAME_RATE = 30;
160 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
161 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
162 vDecSample->WaitForEOS();
163 ASSERT_EQ(0, vDecSample->errCount);
164 }
165
166 /**
167 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0400
168 * @tc.name : decode mpeg2 stream in buffer mode ,output pixel format is RGBa
169 * @tc.desc : FUNCTION test
170 */
171 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0400, TestSize.Level2)
172 {
173 auto vDecSample = make_shared<VDecNdkSample>();
174 vDecSample->INP_DIR = INP_DIR_2;
175 vDecSample->DEFAULT_WIDTH = 640;
176 vDecSample->DEFAULT_HEIGHT = 480;
177 vDecSample->DEFAULT_FRAME_RATE = 30;
178 vDecSample->checkOutPut = false;
179 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
180 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
181 vDecSample->WaitForEOS();
182 ASSERT_EQ(0, vDecSample->errCount);
183 }
184
185 /**
186 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0500
187 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is NV12
188 * @tc.desc : FUNCTION test
189 */
190 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0500, TestSize.Level2)
191 {
192 auto vDecSample = make_shared<VDecNdkSample>();
193 vDecSample->INP_DIR = INP_DIR_2;
194 vDecSample->DEFAULT_WIDTH = 640;
195 vDecSample->DEFAULT_HEIGHT = 480;
196 vDecSample->DEFAULT_FRAME_RATE = 30;
197 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV12;
198 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
199 vDecSample->WaitForEOS();
200 bool isVaild = false;
201 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
202 ASSERT_EQ(false, isVaild);
203 ASSERT_EQ(0, vDecSample->errCount);
204 }
205
206 /**
207 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0600
208 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is NV21
209 * @tc.desc : FUNCTION test
210 */
211 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0600, TestSize.Level2)
212 {
213 auto vDecSample = make_shared<VDecNdkSample>();
214 vDecSample->INP_DIR = INP_DIR_2;
215 vDecSample->DEFAULT_WIDTH = 640;
216 vDecSample->DEFAULT_HEIGHT = 480;
217 vDecSample->DEFAULT_FRAME_RATE = 30;
218 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
219 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
220 vDecSample->WaitForEOS();
221 bool isVaild = false;
222 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
223 ASSERT_EQ(false, isVaild);
224 ASSERT_EQ(0, vDecSample->errCount);
225 }
226
227 /**
228 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0700
229 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is YUV420
230 * @tc.desc : FUNCTION test
231 */
232 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0700, TestSize.Level2)
233 {
234 auto vDecSample = make_shared<VDecNdkSample>();
235 vDecSample->INP_DIR = INP_DIR_2;
236 vDecSample->DEFAULT_WIDTH = 640;
237 vDecSample->DEFAULT_HEIGHT = 480;
238 vDecSample->DEFAULT_FRAME_RATE = 30;
239 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_YUVI420;
240 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
241 vDecSample->WaitForEOS();
242 bool isVaild = false;
243 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
244 ASSERT_EQ(false, isVaild);
245 ASSERT_EQ(0, vDecSample->errCount);
246 }
247
248 /**
249 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0800
250 * @tc.name : decode mpeg2 stream in surface mode ,output pixel format is RGBa
251 * @tc.desc : FUNCTION test
252 */
253 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0800, TestSize.Level2)
254 {
255 auto vDecSample = make_shared<VDecNdkSample>();
256 vDecSample->INP_DIR = INP_DIR_2;
257 vDecSample->DEFAULT_WIDTH = 640;
258 vDecSample->DEFAULT_HEIGHT = 480;
259 vDecSample->DEFAULT_FRAME_RATE = 30;
260 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
261 vDecSample->checkOutPut = false;
262 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
263 vDecSample->WaitForEOS();
264 bool isVaild = false;
265 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
266 ASSERT_EQ(false, isVaild);
267 ASSERT_EQ(0, vDecSample->errCount);
268 }
269
270 /**
271 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_0900
272 * @tc.name : decode mpeg2 stream ,under buffer mode
273 * @tc.desc : FUNCTION test
274 */
275 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_0900, TestSize.Level2)
276 {
277 DecInfo fileTest1{INP_DIR_1, 352, 288, 30};
278 RunDec(fileTest1);
279 DecInfo fileTest2{INP_DIR_2, 640, 480, 30};
280 RunDec(fileTest2);
281 DecInfo fileTest3{INP_DIR_3, 352, 288, 30};
282 RunDec(fileTest3);
283 DecInfo fileTest4{INP_DIR_4, 640, 480, 30};
284 RunDec(fileTest4);
285 DecInfo fileTest5{INP_DIR_5, 1280, 720, 60};
286 RunDec(fileTest5);
287 DecInfo fileTest6{INP_DIR_6, 1920, 1080, 60};
288 RunDec(fileTest6);
289 DecInfo fileTest7{INP_DIR_7, 352, 288, 30};
290 RunDec(fileTest7);
291 DecInfo fileTest8{INP_DIR_8, 640, 480, 30};
292 RunDec(fileTest8);
293 DecInfo fileTest9{INP_DIR_9, 1920, 1080, 60};
294 RunDec(fileTest9);
295 DecInfo fileTest10{INP_DIR_10, 352, 288, 30};
296 RunDec(fileTest10);
297 DecInfo fileTest11{INP_DIR_11, 640, 480, 30};
298 RunDec(fileTest11);
299 DecInfo fileTest12{INP_DIR_12, 1280, 720, 60};
300 RunDec(fileTest12);
301 DecInfo fileTest13{INP_DIR_13, 1920, 1080, 60};
302 RunDec(fileTest13);
303 DecInfo fileTest14{INP_DIR_14, 352, 288, 30};
304 RunDec(fileTest14);
305 DecInfo fileTest15{INP_DIR_15, 640, 480, 30};
306 RunDec(fileTest15);
307 DecInfo fileTest16{INP_DIR_16, 1280, 720, 60};
308 RunDec(fileTest16);
309 DecInfo fileTest17{INP_DIR_17, 1920, 1080, 60};
310 RunDec(fileTest17);
311 DecInfo fileTest18{INP_DIR_18, 640, 480, 30};
312 RunDec(fileTest18);
313 DecInfo fileTest19{INP_DIR_19, 1280, 720, 60};
314 RunDec(fileTest19);
315 DecInfo fileTest20{INP_DIR_20, 1920, 1080, 60};
316 RunDec(fileTest20);
317 }
318
319 /**
320 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1000
321 * @tc.name : odd resolution of 641 * 481
322 * @tc.desc : FUNCTION test
323 */
324 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1000, TestSize.Level2)
325 {
326 auto vDecSample = make_shared<VDecNdkSample>();
327 vDecSample->INP_DIR = "/data/test/media/simple@main_level_641_481_30.m2v";
328 vDecSample->DEFAULT_WIDTH = 641;
329 vDecSample->DEFAULT_HEIGHT = 481;
330 vDecSample->DEFAULT_FRAME_RATE = 30;
331 vDecSample->SURFACE_OUTPUT = false;
332 vDecSample->checkOutPut = false;
333 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
334 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
335 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
336 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
337 vDecSample->WaitForEOS();
338 ASSERT_EQ(0, vDecSample->errCount);
339 }
340
341 /**
342 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1100
343 * @tc.name : odd resolution of 1281 * 721
344 * @tc.desc : FUNCTION test
345 */
346 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1100, TestSize.Level2)
347 {
348 auto vDecSample = make_shared<VDecNdkSample>();
349 vDecSample->INP_DIR = "/data/test/media/main@high14_level_1281_721_60.m2v";
350 vDecSample->DEFAULT_WIDTH = 1281;
351 vDecSample->DEFAULT_HEIGHT = 721;
352 vDecSample->DEFAULT_FRAME_RATE = 60;
353 vDecSample->SURFACE_OUTPUT = false;
354 vDecSample->checkOutPut = false;
355 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
356 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
357 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
358 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
359 vDecSample->WaitForEOS();
360 ASSERT_EQ(0, vDecSample->errCount);
361 }
362
363 /**
364 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1200
365 * @tc.name : mpeg2 decode res change video
366 * @tc.desc : FUNCTION test
367 */
368 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1200, TestSize.Level2)
369 {
370 auto vDecSample = make_shared<VDecNdkSample>();
371 vDecSample->INP_DIR = "/data/test/media/mpeg2_res_change.m2v";
372 vDecSample->DEFAULT_WIDTH = 1920;
373 vDecSample->DEFAULT_HEIGHT = 1080;
374 vDecSample->DEFAULT_FRAME_RATE = 30;
375 vDecSample->SURFACE_OUTPUT = false;
376 vDecSample->checkOutPut = false;
377 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
378 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
379 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
380 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
381 vDecSample->WaitForEOS();
382 ASSERT_EQ(0, vDecSample->errCount);
383 }
384
385 /**
386 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1300
387 * @tc.name : rotation is 90
388 * @tc.desc : FUNCTION test
389 */
390 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1300, TestSize.Level2)
391 {
392 auto vDecSample = make_shared<VDecNdkSample>();
393 vDecSample->INP_DIR = "/data/test/media/simple@low_level_352_288_30_rotation_90.m2v";
394 vDecSample->DEFAULT_WIDTH = 352;
395 vDecSample->DEFAULT_HEIGHT = 288;
396 vDecSample->DEFAULT_FRAME_RATE = 30;
397 vDecSample->DEFAULT_ROTATION = 90;
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 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1400
410 * @tc.name : rotation is 180
411 * @tc.desc : FUNCTION test
412 */
413 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1400, TestSize.Level2)
414 {
415 auto vDecSample = make_shared<VDecNdkSample>();
416 vDecSample->INP_DIR = "/data/test/media/simple@low_level_352_288_30_rotation_180.m2v";
417 vDecSample->DEFAULT_WIDTH = 352;
418 vDecSample->DEFAULT_HEIGHT = 288;
419 vDecSample->DEFAULT_FRAME_RATE = 30;
420 vDecSample->DEFAULT_ROTATION = 180;
421 vDecSample->SURFACE_OUTPUT = false;
422 vDecSample->checkOutPut = false;
423 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
424 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
425 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
426 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
427 vDecSample->WaitForEOS();
428 ASSERT_EQ(0, vDecSample->errCount);
429 }
430
431 /**
432 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1500
433 * @tc.name : rotation is 270
434 * @tc.desc : FUNCTION test
435 */
436 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1500, TestSize.Level2)
437 {
438 auto vDecSample = make_shared<VDecNdkSample>();
439 vDecSample->INP_DIR = "/data/test/media/simple@low_level_352_288_30_rotation_270.m2v";
440 vDecSample->DEFAULT_WIDTH = 352;
441 vDecSample->DEFAULT_HEIGHT = 288;
442 vDecSample->DEFAULT_FRAME_RATE = 30;
443 vDecSample->DEFAULT_ROTATION = 270;
444 vDecSample->SURFACE_OUTPUT = false;
445 vDecSample->checkOutPut = false;
446 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
447 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
448 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
449 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
450 vDecSample->WaitForEOS();
451 ASSERT_EQ(0, vDecSample->errCount);
452 }
453
454 /**
455 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1600
456 * @tc.name : unaligned byte test
457 * @tc.desc : FUNCTION test
458 */
459 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1600, TestSize.Level2)
460 {
461 auto vDecSample = make_shared<VDecNdkSample>();
462 vDecSample->INP_DIR = "/data/test/media/simple@low_level_353_289_30.m2v";
463 vDecSample->DEFAULT_WIDTH = 353;
464 vDecSample->DEFAULT_HEIGHT = 289;
465 vDecSample->DEFAULT_FRAME_RATE = 30;
466 vDecSample->SURFACE_OUTPUT = false;
467 vDecSample->checkOutPut = false;
468 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
469 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
470 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
471 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
472 vDecSample->WaitForEOS();
473 ASSERT_EQ(0, vDecSample->errCount);
474 }
475
476 /**
477 * @tc.number : VIDEO_MPEG2SWDEC_FUNCTION_1700
478 * @tc.name : mpeg2 decode err resolution
479 * @tc.desc : FUNCTION test
480 */
481 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2SWDEC_FUNCTION_1700, TestSize.Level2)
482 {
483 auto vDecSample = make_shared<VDecNdkSample>();
484 vDecSample->INP_DIR = "/data/test/media/mpeg2_err_res.m2v";
485 vDecSample->DEFAULT_WIDTH = 1920;
486 vDecSample->DEFAULT_HEIGHT = 1080;
487 vDecSample->DEFAULT_FRAME_RATE = 30;
488 vDecSample->SURFACE_OUTPUT = false;
489 vDecSample->checkOutPut = false;
490 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
491 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
492 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
493 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
494 vDecSample->WaitForEOS();
495 ASSERT_EQ(0, vDecSample->errCount);
496 }
497
498 /**
499 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0100
500 * @tc.name : 1080p ,surf model change in normal state
501 * @tc.desc : FUNCTION test
502 */
503 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0100, TestSize.Level2)
504 {
505 auto vDecSample = make_shared<VDecAPI11Sample>();
506 vDecSample->INP_DIR = INP_DIR_6;
507 vDecSample->DEFAULT_WIDTH = 1920;
508 vDecSample->DEFAULT_HEIGHT = 1080;
509 vDecSample->DEFAULT_FRAME_RATE = 60;
510 vDecSample->SURFACE_OUTPUT = true;
511 vDecSample->autoSwitchSurface = true;
512 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
513 vDecSample->sleepOnFPS = true;
514 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
515 vDecSample->WaitForEOS();
516 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
517 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
518 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
519 }
520
521 /**
522 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0200
523 * @tc.name : 1080p ,surf model change in flushed state
524 * @tc.desc : FUNCTION test
525 */
526 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0200, TestSize.Level2)
527 {
528 auto vDecSample = make_shared<VDecAPI11Sample>();
529 vDecSample->INP_DIR = INP_DIR_6;
530 vDecSample->DEFAULT_WIDTH = 1920;
531 vDecSample->DEFAULT_HEIGHT = 1080;
532 vDecSample->DEFAULT_FRAME_RATE = 60;
533 vDecSample->SURFACE_OUTPUT = true;
534 vDecSample->autoSwitchSurface = true;
535 vDecSample->sleepOnFPS = true;
536 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
537 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
538 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
539 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
540 }
541
542 /**
543 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0300
544 * @tc.name : 1080p ,surf model change in runing state
545 * @tc.desc : FUNCTION test
546 */
547 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0300, TestSize.Level2)
548 {
549 auto vDecSample = make_shared<VDecAPI11Sample>();
550 vDecSample->INP_DIR = INP_DIR_6;
551 vDecSample->DEFAULT_WIDTH = 1920;
552 vDecSample->DEFAULT_HEIGHT = 1080;
553 vDecSample->DEFAULT_FRAME_RATE = 60;
554 vDecSample->SURFACE_OUTPUT = false;
555 vDecSample->autoSwitchSurface = false;
556 vDecSample->CreateSurface();
557 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameMpeg2));
558 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
559 vDecSample->WaitForEOS();
560 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
561 }
562
563 /**
564 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0400
565 * @tc.name : 1080p ,repeat call setSurface fastly
566 * @tc.desc : FUNCTION test
567 */
568 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0400, TestSize.Level2)
569 {
570 auto vDecSample = make_shared<VDecAPI11Sample>();
571 vDecSample->INP_DIR = INP_DIR_6;
572 vDecSample->DEFAULT_WIDTH = 1920;
573 vDecSample->DEFAULT_HEIGHT = 1080;
574 vDecSample->DEFAULT_FRAME_RATE = 60;
575 vDecSample->SURFACE_OUTPUT = true;
576 vDecSample->autoSwitchSurface = true;
577 vDecSample->sleepOnFPS = true;
578 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
579 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
580 vDecSample->WaitForEOS();
581 }
582
583 /**
584 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0500
585 * @tc.name : 1080p ,surf model change in flush to runnig state
586 * @tc.desc : FUNCTION test
587 */
588 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0500, TestSize.Level2)
589 {
590 auto vDecSample = make_shared<VDecAPI11Sample>();
591 vDecSample->INP_DIR = INP_DIR_6;
592 vDecSample->DEFAULT_WIDTH = 1920;
593 vDecSample->DEFAULT_HEIGHT = 1080;
594 vDecSample->DEFAULT_FRAME_RATE = 60;
595 vDecSample->SURFACE_OUTPUT = true;
596 vDecSample->autoSwitchSurface = true;
597 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
598 vDecSample->sleepOnFPS = true;
599 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
600 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
601 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
602 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
603 }
604
605 /**
606 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0600
607 * @tc.name : 1080p ,surf model change in decoder finish to End-of-Stream state
608 * @tc.desc : FUNCTION test
609 */
610 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0600, TestSize.Level2)
611 {
612 auto vDecSample = make_shared<VDecAPI11Sample>();
613 vDecSample->INP_DIR = INP_DIR_6;
614 vDecSample->DEFAULT_WIDTH = 1920;
615 vDecSample->DEFAULT_HEIGHT = 1080;
616 vDecSample->DEFAULT_FRAME_RATE = 60;
617 vDecSample->autoSwitchSurface = true;
618 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
619 vDecSample->sleepOnFPS = true;
620 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
621 vDecSample->WaitForEOS();
622 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
623 }
624
625 /**
626 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0700
627 * @tc.name : 1080p ,surf model change in config state
628 * @tc.desc : FUNCTION test
629 */
630 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0700, TestSize.Level2)
631 {
632 auto vDecSample = make_shared<VDecAPI11Sample>();
633 vDecSample->INP_DIR = INP_DIR_6;
634 vDecSample->DEFAULT_WIDTH = 1920;
635 vDecSample->DEFAULT_HEIGHT = 1080;
636 vDecSample->DEFAULT_FRAME_RATE = 60;
637 vDecSample->SURFACE_OUTPUT = false;
638 vDecSample->autoSwitchSurface = false;
639 vDecSample->CreateSurface();
640 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
641 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
642 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
643 vDecSample->WaitForEOS();
644 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
645 }
646
647 /**
648 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0800
649 * @tc.name : Two object repeat call setSurface fastly
650 * @tc.desc : FUNCTION test
651 */
652 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0800, TestSize.Level2)
653 {
654 auto vDecSample = make_shared<VDecAPI11Sample>();
655 vDecSample->INP_DIR = INP_DIR_6;
656 vDecSample->DEFAULT_WIDTH = 1920;
657 vDecSample->DEFAULT_HEIGHT = 1080;
658 vDecSample->DEFAULT_FRAME_RATE = 60;
659 vDecSample->autoSwitchSurface = true;
660 vDecSample->sleepOnFPS = true;
661 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
662 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
663 vDecSample->WaitForEOS();
664
665 auto vDecSample_1 = make_shared<VDecAPI11Sample>();
666 vDecSample_1->INP_DIR = INP_DIR_6;
667 vDecSample_1->DEFAULT_WIDTH = 1920;
668 vDecSample_1->DEFAULT_HEIGHT = 1080;
669 vDecSample_1->DEFAULT_FRAME_RATE = 60;
670 vDecSample_1->autoSwitchSurface = true;
671 vDecSample_1->sleepOnFPS = true;
672 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RunVideoDec_Surface(g_codecNameMpeg2));
673 ASSERT_EQ(AV_ERR_OK, vDecSample_1->SwitchSurface());
674 vDecSample_1->WaitForEOS();
675 }
676
677 /**
678 * @tc.number : VIDEO_MPEG2VIDEO_SURF_CHANGE_0900
679 * @tc.name : repeat call setSurface fastly 2 time
680 * @tc.desc : FUNCTION test
681 */
682 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_SURF_CHANGE_0900, TestSize.Level2)
683 {
684 for (int i = 0; i < 2; i++) {
685 auto vDecSample = make_shared<VDecAPI11Sample>();
686 vDecSample->INP_DIR = INP_DIR_6;
687 vDecSample->DEFAULT_WIDTH = 1920;
688 vDecSample->DEFAULT_HEIGHT = 1080;
689 vDecSample->DEFAULT_FRAME_RATE = 60;
690 vDecSample->autoSwitchSurface = true;
691 vDecSample->sleepOnFPS = true;
692 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameMpeg2));
693 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
694 vDecSample->WaitForEOS();
695 }
696 }
697
698 /**
699 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0100
700 * @tc.name : width is -1 ,height is -1
701 * @tc.desc : FUNCTION test
702 */
703 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0100, TestSize.Level2)
704 {
705 auto vDecSample = make_shared<VDecNdkSample>();
706 vDecSample->INP_DIR = INP_DIR_2;
707 vDecSample->DEFAULT_WIDTH = -1;
708 vDecSample->DEFAULT_HEIGHT = -1;
709 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
710 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
711 ASSERT_EQ(0, vDecSample->errCount);
712 }
713
714 /**
715 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0200
716 * @tc.name : width is 0 ,height is 0
717 * @tc.desc : FUNCTION test
718 */
719 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0200, TestSize.Level2)
720 {
721 auto vDecSample = make_shared<VDecNdkSample>();
722 vDecSample->INP_DIR = INP_DIR_2;
723 vDecSample->DEFAULT_WIDTH = 0;
724 vDecSample->DEFAULT_HEIGHT = 0;
725 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
726 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
727 ASSERT_EQ(0, vDecSample->errCount);
728 }
729
730 /**
731 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0300
732 * @tc.name : width is 1 ,height is 1
733 * @tc.desc : FUNCTION test
734 */
735 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0300, TestSize.Level2)
736 {
737 auto vDecSample = make_shared<VDecNdkSample>();
738 vDecSample->INP_DIR = INP_DIR_2;
739 vDecSample->DEFAULT_WIDTH = 1;
740 vDecSample->DEFAULT_HEIGHT = 1;
741 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
742 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
743 ASSERT_EQ(0, vDecSample->errCount);
744 }
745
746 /**
747 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0400
748 * @tc.name : width is 1920 ,height is 1080
749 * @tc.desc : FUNCTION test
750 */
751 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0400, TestSize.Level2)
752 {
753 auto vDecSample = make_shared<VDecNdkSample>();
754 vDecSample->INP_DIR = INP_DIR_2;
755 vDecSample->DEFAULT_WIDTH = 1920;
756 vDecSample->DEFAULT_HEIGHT = 1080;
757 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
758 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
759 ASSERT_EQ(0, vDecSample->errCount);
760 }
761
762 /**
763 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0500
764 * @tc.name : width is 4097 ,height is 4097
765 * @tc.desc : FUNCTION test
766 */
767 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0500, TestSize.Level2)
768 {
769 auto vDecSample = make_shared<VDecNdkSample>();
770 vDecSample->INP_DIR = INP_DIR_2;
771 vDecSample->DEFAULT_WIDTH = 4097;
772 vDecSample->DEFAULT_HEIGHT = 4097;
773 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
774 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
775 ASSERT_EQ(0, vDecSample->errCount);
776 }
777
778 /**
779 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0600
780 * @tc.name : width is 10000 ,height is 10000
781 * @tc.desc : FUNCTION test
782 */
783 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0600, TestSize.Level2)
784 {
785 auto vDecSample = make_shared<VDecNdkSample>();
786 vDecSample->INP_DIR = INP_DIR_2;
787 vDecSample->DEFAULT_WIDTH = 10000;
788 vDecSample->DEFAULT_HEIGHT = 10000;
789 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
790 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
791 ASSERT_EQ(0, vDecSample->errCount);
792 }
793
794 /**
795 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0700
796 * @tc.name : framerate is -1
797 * @tc.desc : FUNCTION test
798 */
799 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0700, TestSize.Level2)
800 {
801 auto vDecSample = make_shared<VDecNdkSample>();
802 vDecSample->INP_DIR = INP_DIR_2;
803 vDecSample->DEFAULT_WIDTH = 640;
804 vDecSample->DEFAULT_HEIGHT = 480;
805 vDecSample->DEFAULT_FRAME_RATE = -1;
806 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
807 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
808 ASSERT_EQ(0, vDecSample->errCount);
809 }
810
811 /**
812 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0800
813 * @tc.name : framerate is 0
814 * @tc.desc : FUNCTION test
815 */
816 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0800, TestSize.Level2)
817 {
818 auto vDecSample = make_shared<VDecNdkSample>();
819 vDecSample->INP_DIR = INP_DIR_2;
820 vDecSample->DEFAULT_WIDTH = 640;
821 vDecSample->DEFAULT_HEIGHT = 480;
822 vDecSample->DEFAULT_FRAME_RATE = 0;
823 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
824 ASSERT_NE(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
825 ASSERT_EQ(0, vDecSample->errCount);
826 }
827
828 /**
829 * @tc.number : VIDEO_MPEG2VIDEO_PARA_0900
830 * @tc.name : framerate is 10000
831 * @tc.desc : FUNCTION test
832 */
833 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_0900, TestSize.Level2)
834 {
835 auto vDecSample = make_shared<VDecNdkSample>();
836 vDecSample->INP_DIR = INP_DIR_2;
837 vDecSample->DEFAULT_WIDTH = 640;
838 vDecSample->DEFAULT_HEIGHT = 480;
839 vDecSample->DEFAULT_FRAME_RATE = 10000;
840 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
841 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
842 vDecSample->WaitForEOS();
843 ASSERT_EQ(0, vDecSample->errCount);
844 }
845
846 /**
847 * @tc.number : VIDEO_MPEG2VIDEO_PARA_1000
848 * @tc.name : MPEG2 decoder, MPEG4 input
849 * @tc.desc : FUNCTION test
850 */
851 HWTEST_F(Mpeg2SwdecFuncNdkTest, VIDEO_MPEG2VIDEO_PARA_1000, TestSize.Level2)
852 {
853 auto vDecSample = make_shared<VDecNdkSample>();
854 vDecSample->INP_DIR = "/data/test/media/mpeg4.m4v";
855 vDecSample->DEFAULT_WIDTH = 1280;
856 vDecSample->DEFAULT_HEIGHT = 720;
857 vDecSample->DEFAULT_FRAME_RATE = 30;
858 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameMpeg2));
859 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
860 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
861 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
862 vDecSample->WaitForEOS();
863 ASSERT_EQ(0, vDecSample->errCount);
864 }
865 }