1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <string>
16 #include "gtest/gtest.h"
17 #include "native_avcodec_videodecoder.h"
18 #include "native_averrors.h"
19 #include "videodec_ndk_sample.h"
20 #include "videodec_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24
25 namespace {
26 OH_AVCapability *cap = nullptr;
27 std::string g_codecNameAvc = "";
28 OH_AVCapability *cap_hevc = nullptr;
29 } // namespace
30 #ifdef SUPPORT_DRM
31 #include "native_mediakeysession.h"
32 #include "native_mediakeysystem.h"
33 #endif
34
35 #define MAX_THREAD 16
36
37 using namespace std;
38 using namespace OHOS;
39 using namespace OHOS::Media;
40 using namespace testing::ext;
41
42 namespace OHOS {
43 namespace Media {
44 class SwdecFuncNdkTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp() override;
49 void TearDown() override;
50 void InputFunc();
51 void OutputFunc();
52 void Release();
53 int32_t Stop();
54
55 protected:
56 const string CODEC_NAME = "video_decoder.avc";
57 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
58 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
59 };
60 } // namespace Media
61 } // namespace OHOS
62
SetUpTestCase()63 void SwdecFuncNdkTest::SetUpTestCase()
64 {
65 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
66 g_codecNameAvc = OH_AVCapability_GetName(cap);
67 cout << "g_codecNameAvc: " << g_codecNameAvc << endl;
68 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
69 }
TearDownTestCase()70 void SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()71 void SwdecFuncNdkTest::SetUp() {}
TearDown()72 void SwdecFuncNdkTest::TearDown() {}
73
74 namespace {
75 /**
76 * @tc.number : VIDEO_SWDEC_FUNCTION_0200
77 * @tc.name : create nonexist decoder
78 * @tc.desc : function test
79 */
80 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0200, TestSize.Level1)
81 {
82 OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
83 ASSERT_EQ(nullptr, vdec_);
84 }
85
86 /**
87 * @tc.number : VIDEO_SWDEC_FUNCTION_0300
88 * @tc.name : test h264 decode buffer
89 * @tc.desc : function test
90 */
91 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0300, TestSize.Level0)
92 {
93 if (cap) {
94 auto vDecSample = make_shared<VDecNdkSample>();
95 vDecSample->INP_DIR = INP_DIR_1080_30;
96 vDecSample->DEFAULT_WIDTH = 1920;
97 vDecSample->DEFAULT_HEIGHT = 1080;
98 vDecSample->DEFAULT_FRAME_RATE = 30;
99 vDecSample->SURFACE_OUTPUT = false;
100 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
101 vDecSample->WaitForEOS();
102 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
103 }
104 }
105
106 /**
107 * @tc.number : VIDEO_SWDEC_FUNCTION_0400
108 * @tc.name : test h264 decode surface
109 * @tc.desc : function test
110 */
111 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
112 {
113 if (cap) {
114 auto vDecSample = make_shared<VDecNdkSample>();
115 vDecSample->INP_DIR = INP_DIR_1080_30;
116 vDecSample->SURFACE_OUTPUT = true;
117 vDecSample->DEFAULT_WIDTH = 1920;
118 vDecSample->DEFAULT_HEIGHT = 1080;
119 vDecSample->DEFAULT_FRAME_RATE = 30;
120 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
121 vDecSample->WaitForEOS();
122 bool isVaild = false;
123 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
124 ASSERT_EQ(false, isVaild);
125 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
126 }
127 }
128
129 /**
130 * @tc.number : VIDEO_SWDEC_FUNCTION_0700
131 * @tc.name : test set EOS when last frame
132 * @tc.desc : function test
133 */
134 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
135 {
136 if (cap) {
137 auto vDecSample = make_shared<VDecNdkSample>();
138 vDecSample->INP_DIR = INP_DIR_1080_30;
139 vDecSample->DEFAULT_WIDTH = 1920;
140 vDecSample->DEFAULT_HEIGHT = 1080;
141 vDecSample->DEFAULT_FRAME_RATE = 30;
142 vDecSample->SURFACE_OUTPUT = false;
143 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
144 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
145 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
146 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
147 vDecSample->WaitForEOS();
148 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
149 }
150 }
151
152 /**
153 * @tc.number : VIDEO_SWDEC_FUNCTION_0800
154 * @tc.name : test set EOS before last frame then stop
155 * @tc.desc : function test
156 */
157 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
158 {
159 if (cap) {
160 auto vDecSample = make_shared<VDecNdkSample>();
161 vDecSample->INP_DIR = INP_DIR_1080_30;
162 vDecSample->DEFAULT_WIDTH = 1920;
163 vDecSample->DEFAULT_HEIGHT = 1080;
164 vDecSample->DEFAULT_FRAME_RATE = 30;
165 vDecSample->SURFACE_OUTPUT = false;
166 vDecSample->BEFORE_EOS_INPUT = true;
167 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
168 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
169 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
170 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
171 vDecSample->WaitForEOS();
172 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
173 }
174 }
175 /**
176 * @tc.number : VIDEO_SWDEC_FUNCTION_4000
177 * @tc.name : test set EOS before last frame then stop surface
178 * @tc.desc : function test
179 */
180
181 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_4000, TestSize.Level1)
182 {
183 if (cap) {
184 auto vDecSample = make_shared<VDecNdkSample>();
185 vDecSample->INP_DIR = INP_DIR_1080_30;
186 vDecSample->DEFAULT_WIDTH = 1920;
187 vDecSample->DEFAULT_HEIGHT = 1080;
188 vDecSample->DEFAULT_FRAME_RATE = 30;
189 vDecSample->SURFACE_OUTPUT = true;
190 vDecSample->BEFORE_EOS_INPUT = true;
191 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
192 vDecSample->WaitForEOS();
193 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
194 }
195 }
196
197 /**
198 * @tc.number : VIDEO_SWDEC_FUNCTION_1000
199 * @tc.name : test reconfigure for new file with one decoder
200 * @tc.desc : function test
201 */
202 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
203 {
204 if (cap) {
205 auto vDecSample = make_shared<VDecNdkSample>();
206 vDecSample->INP_DIR = INP_DIR_1080_30;
207 vDecSample->DEFAULT_WIDTH = 1920;
208 vDecSample->DEFAULT_HEIGHT = 1080;
209 vDecSample->DEFAULT_FRAME_RATE = 30;
210 vDecSample->SURFACE_OUTPUT = false;
211 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
212 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
213 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
214 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
215 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
216 vDecSample->WaitForEOS();
217 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
218 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
219 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
220 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
221 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
222 vDecSample->WaitForEOS();
223 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
224 }
225 }
226
227 /**
228 * @tc.number : VIDEO_SWDEC_FUNCTION_1100
229 * @tc.name : test reconfigure for new file with the recreated decoder
230 * @tc.desc : function test
231 */
232 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
233 {
234 if (cap) {
235 auto vDecSample = make_shared<VDecNdkSample>();
236 vDecSample->INP_DIR = INP_DIR_1080_30;
237 vDecSample->DEFAULT_WIDTH = 1920;
238 vDecSample->DEFAULT_HEIGHT = 1080;
239 vDecSample->DEFAULT_FRAME_RATE = 30;
240 vDecSample->SURFACE_OUTPUT = false;
241 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
242 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
243 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
244 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
245 vDecSample->WaitForEOS();
246 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
247 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
248 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
249 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
250 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
251 vDecSample->WaitForEOS();
252 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
253 }
254 }
255
256 /**
257 * @tc.number : VIDEO_SWDEC_FUNCTION_1200
258 * @tc.name : repeat start and stop 5 times before EOS
259 * @tc.desc : function test
260 */
261 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
262 {
263 if (cap) {
264 auto vDecSample = make_shared<VDecNdkSample>();
265 vDecSample->INP_DIR = INP_DIR_1080_30;
266 vDecSample->DEFAULT_WIDTH = 1920;
267 vDecSample->DEFAULT_HEIGHT = 1080;
268 vDecSample->DEFAULT_FRAME_RATE = 30;
269 vDecSample->SURFACE_OUTPUT = false;
270 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
271 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
272 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
273 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
274 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
275 vDecSample->WaitForEOS();
276 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
277 }
278 }
279
280 /**
281 * @tc.number : VIDEO_SWDEC_FUNCTION_1300
282 * @tc.name : repeat start and flush 5 times before EOS
283 * @tc.desc : function test
284 */
285 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
286 {
287 if (cap) {
288 auto vDecSample = make_shared<VDecNdkSample>();
289 vDecSample->INP_DIR = INP_DIR_1080_30;
290 vDecSample->DEFAULT_WIDTH = 1920;
291 vDecSample->DEFAULT_HEIGHT = 1080;
292 vDecSample->DEFAULT_FRAME_RATE = 30;
293 vDecSample->SURFACE_OUTPUT = false;
294 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
295 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
296 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
297 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
298 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
299 vDecSample->WaitForEOS();
300 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
301 }
302 }
303
304 /**
305 * @tc.number : VIDEO_SWDEC_FUNCTION_1400
306 * @tc.name : set larger width and height
307 * @tc.desc : function test
308 */
309 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1400, TestSize.Level2)
310 {
311 if (cap) {
312 auto vDecSample = make_shared<VDecNdkSample>();
313 vDecSample->INP_DIR = INP_DIR_720_30;
314 vDecSample->DEFAULT_WIDTH = 1920;
315 vDecSample->DEFAULT_HEIGHT = 1080;
316 vDecSample->DEFAULT_FRAME_RATE = 30;
317 vDecSample->SURFACE_OUTPUT = false;
318 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
319 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
320 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
321 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
322 vDecSample->WaitForEOS();
323 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
324 }
325 }
326
327 /**
328 * @tc.number : VIDEO_SWDEC_FUNCTION_1500
329 * @tc.name : set the width and height to a samller value
330 * @tc.desc : function test
331 */
332 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1500, TestSize.Level2)
333 {
334 if (cap) {
335 auto vDecSample = make_shared<VDecNdkSample>();
336 vDecSample->INP_DIR = INP_DIR_1080_30;
337 vDecSample->DEFAULT_WIDTH = 1280;
338 vDecSample->DEFAULT_HEIGHT = 720;
339 vDecSample->DEFAULT_FRAME_RATE = 30;
340 vDecSample->SURFACE_OUTPUT = false;
341 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
342 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
343 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
344 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
345 vDecSample->WaitForEOS();
346 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
347 }
348 }
349
350 /**
351 * @tc.number : VIDEO_SWDEC_FUNCTION_1600
352 * @tc.name : resolution change
353 * @tc.desc : function test
354 */
355 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1600, TestSize.Level2)
356 {
357 if (cap) {
358 auto vDecSample = make_shared<VDecNdkSample>();
359 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
360 vDecSample->DEFAULT_WIDTH = 1104;
361 vDecSample->DEFAULT_HEIGHT = 622;
362 vDecSample->DEFAULT_FRAME_RATE = 30;
363 vDecSample->SURFACE_OUTPUT = false;
364 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
365 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
366 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
367 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
368 vDecSample->WaitForEOS();
369 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
370 }
371 }
372
373 /**
374 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0010
375 * @tc.name : VIDEO_DECODE_SYNC_SW264_FUNC_0010
376 * @tc.desc : function test
377 */
378 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0010, TestSize.Level1)
379 {
380 if (cap != nullptr) {
381 auto vDecSample = make_shared<VDecAPI11Sample>();
382 vDecSample->INP_DIR = INP_DIR_1080_30;
383 vDecSample->DEFAULT_WIDTH = 1920;
384 vDecSample->DEFAULT_HEIGHT = 1080;
385 vDecSample->DEFAULT_FRAME_RATE = 30;
386 vDecSample->enbleSyncMode = 1;
387 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
388 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
389 vDecSample->sleepOnFPS = true;
390 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
391 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
392 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
393 vDecSample->WaitForEOS();
394 ASSERT_EQ(0, vDecSample->errCount);
395 }
396 }
397
398 /**
399 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0020
400 * @tc.name : VIDEO_DECODE_SYNC_SW264_FUNC_0020
401 * @tc.desc : function test
402 */
403 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0020, TestSize.Level0)
404 {
405 if (cap != nullptr) {
406 auto vDecSample = make_shared<VDecAPI11Sample>();
407 vDecSample->INP_DIR = INP_DIR_1080_30;
408 vDecSample->DEFAULT_WIDTH = 1920;
409 vDecSample->DEFAULT_HEIGHT = 1080;
410 vDecSample->DEFAULT_FRAME_RATE = 30;
411 vDecSample->enbleSyncMode = 1;
412 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
413 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
414 vDecSample->sleepOnFPS = true;
415 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
416 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
417 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
418 vDecSample->WaitForEOS();
419 ASSERT_EQ(0, vDecSample->errCount);
420 }
421 }
422
423 /**
424 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0040
425 * @tc.name : VIDEO_DECODE_SYNC_SW264_FUNC_0040
426 * @tc.desc : function test
427 */
428 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0040, TestSize.Level1)
429 {
430 if (cap != nullptr) {
431 auto vDecSample = make_shared<VDecAPI11Sample>();
432 vDecSample->INP_DIR = INP_DIR_1080_30;
433 vDecSample->DEFAULT_WIDTH = 1920;
434 vDecSample->DEFAULT_HEIGHT = 1080;
435 vDecSample->DEFAULT_FRAME_RATE = 30;
436 vDecSample->enbleSyncMode = 1;
437 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_RGBA;
438 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
439 vDecSample->sleepOnFPS = true;
440 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
441 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
442 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
443 vDecSample->WaitForEOS();
444 ASSERT_EQ(0, vDecSample->errCount);
445 }
446 }
447
448 /**
449 * @tc.number : VIDEO_SWDECODE_BLANK_FRAME_0010
450 * @tc.name : VIDEO_SWDECODE_BLANK_FRAME_0010
451 * @tc.desc : function test
452 */
453 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDECODE_BLANK_FRAME_0010, TestSize.Level1)
454 {
455 if (cap != nullptr) {
456 auto vDecSample = make_shared<VDecAPI11Sample>();
457 vDecSample->INP_DIR = INP_DIR_1080_30;
458 vDecSample->DEFAULT_WIDTH = 1920;
459 vDecSample->DEFAULT_HEIGHT = 1080;
460 vDecSample->DEFAULT_FRAME_RATE = 30;
461 vDecSample->enbleBlankFrame = 1;
462 vDecSample->SURFACE_OUTPUT = false;
463 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
464 vDecSample->WaitForEOS();
465 ASSERT_EQ(0, vDecSample->errCount);
466 }
467 }
468 } // namespace