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_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
26 #ifdef SUPPORT_DRM
27 #include "native_mediakeysession.h"
28 #include "native_mediakeysystem.h"
29 #endif
30
31 #define MAX_THREAD 16
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace OHOS::Media;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace Media {
40 class SwdecFuncNdkTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 void InputFunc();
47 void OutputFunc();
48 void Release();
49 int32_t Stop();
50
51 protected:
52 const string CODEC_NAME = "video_decoder.avc";
53 const char *INP_DIR_720_30 = "/data/test/media/1280_720_30_10Mb.h264";
54 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_10_30Mb.h264";
55 };
56 } // namespace Media
57 } // namespace OHOS
58
59 namespace {
60 static OH_AVCapability *cap_avc = nullptr;
61 static string g_codecNameAvc = "";
62 } // namespace
63
SetUpTestCase()64 void SwdecFuncNdkTest::SetUpTestCase()
65 {
66 cap_avc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
67 g_codecNameAvc = OH_AVCapability_GetName(cap_avc);
68 cout << "g_codecNameAvc: " << g_codecNameAvc << endl;
69 }
70
TearDownTestCase()71 void SwdecFuncNdkTest::TearDownTestCase() {}
SetUp()72 void SwdecFuncNdkTest::SetUp() {}
TearDown()73 void SwdecFuncNdkTest::TearDown() {}
74
75 namespace {
76 /**
77 * @tc.number : API11_SURF_CHANGE_FUNC_001
78 * @tc.name : surf model change in normal state
79 * @tc.desc : function test
80 */
81 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_001, TestSize.Level0)
82 {
83 if (!access("/system/lib64/media/", 0)) {
84 auto vDecSample = make_shared<VDecAPI11Sample>();
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 = true;
90 vDecSample->autoSwitchSurface = true;
91 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
92 vDecSample->sleepOnFPS = true;
93 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
94 vDecSample->WaitForEOS();
95 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
96 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
97 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
98 }
99 }
100
101 /**
102 * @tc.number : API11_SURF_CHANGE_FUNC_002
103 * @tc.name : surf model change in flushed state
104 * @tc.desc : function test
105 */
106 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_002, TestSize.Level0)
107 {
108 if (!access("/system/lib64/media/", 0)) {
109 auto vDecSample = make_shared<VDecAPI11Sample>();
110 vDecSample->INP_DIR = INP_DIR_1080_30;
111 vDecSample->DEFAULT_WIDTH = 1920;
112 vDecSample->DEFAULT_HEIGHT = 1080;
113 vDecSample->DEFAULT_FRAME_RATE = 30;
114 vDecSample->SURFACE_OUTPUT = true;
115 vDecSample->autoSwitchSurface = true;
116 vDecSample->sleepOnFPS = true;
117 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
118 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
119 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
120 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
121 }
122 }
123
124 /**
125 * @tc.number : API11_SURF_CHANGE_FUNC_003
126 * @tc.name : surf model change in runing state
127 * @tc.desc : function test
128 */
129 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_003, TestSize.Level0)
130 {
131 if (!access("/system/lib64/media/", 0)) {
132 auto vDecSample = make_shared<VDecAPI11Sample>();
133 vDecSample->INP_DIR = INP_DIR_1080_30;
134 vDecSample->DEFAULT_WIDTH = 1920;
135 vDecSample->DEFAULT_HEIGHT = 1080;
136 vDecSample->DEFAULT_FRAME_RATE = 30;
137 vDecSample->SURFACE_OUTPUT = false;
138 vDecSample->autoSwitchSurface = false;
139 vDecSample->CreateSurface();
140 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
141 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
142 vDecSample->WaitForEOS();
143 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
144 }
145 }
146
147 /**
148 * @tc.number : API11_SURF_CHANGE_FUNC_004
149 * @tc.name : repeat call setSurface fastly
150 * @tc.desc : function test
151 */
152 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_004, TestSize.Level0)
153 {
154 if (!access("/system/lib64/media/", 0)) {
155 auto vDecSample = make_shared<VDecAPI11Sample>();
156 vDecSample->INP_DIR = INP_DIR_1080_30;
157 vDecSample->DEFAULT_WIDTH = 1920;
158 vDecSample->DEFAULT_HEIGHT = 1080;
159 vDecSample->DEFAULT_FRAME_RATE = 30;
160 vDecSample->SURFACE_OUTPUT = true;
161 vDecSample->autoSwitchSurface = true;
162 vDecSample->sleepOnFPS = true;
163 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
164 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
165 vDecSample->WaitForEOS();
166 }
167 }
168
169 /**
170 * @tc.number : API11_SURF_CHANGE_FUNC_005
171 * @tc.name : surf model change in flush to runnig state
172 * @tc.desc : function test
173 */
174 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_005, TestSize.Level0)
175 {
176 if (!access("/system/lib64/media/", 0)) {
177 auto vDecSample = make_shared<VDecAPI11Sample>();
178 vDecSample->INP_DIR = INP_DIR_1080_30;
179 vDecSample->DEFAULT_WIDTH = 1920;
180 vDecSample->DEFAULT_HEIGHT = 1080;
181 vDecSample->DEFAULT_FRAME_RATE = 30;
182 vDecSample->SURFACE_OUTPUT = true;
183 vDecSample->autoSwitchSurface = true;
184 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
185 vDecSample->sleepOnFPS = true;
186 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
187 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
188 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
189 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
190 }
191 }
192
193 /**
194 * @tc.number : API11_SURF_CHANGE_FUNC_006
195 * @tc.name : surf model change in decoder finish to End-of-Stream state
196 * @tc.desc : function test
197 */
198 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_006, TestSize.Level0)
199 {
200 if (!access("/system/lib64/media/", 0)) {
201 auto vDecSample = make_shared<VDecAPI11Sample>();
202 vDecSample->INP_DIR = INP_DIR_1080_30;
203 vDecSample->DEFAULT_WIDTH = 1920;
204 vDecSample->DEFAULT_HEIGHT = 1080;
205 vDecSample->DEFAULT_FRAME_RATE = 30;
206 vDecSample->SURFACE_OUTPUT = true;
207 vDecSample->autoSwitchSurface = true;
208 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
209 vDecSample->sleepOnFPS = true;
210 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
211 vDecSample->WaitForEOS();
212 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
213 }
214 }
215
216 /**
217 * @tc.number : API11_SURF_CHANGE_FUNC_007
218 * @tc.name : buffer model change in decoder finish to End-of-Stream state
219 * @tc.desc : function test
220 */
221 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_007, TestSize.Level0)
222 {
223 if (!access("/system/lib64/media/", 0)) {
224 auto vDecSample = make_shared<VDecAPI11Sample>();
225 vDecSample->INP_DIR = INP_DIR_1080_30;
226 vDecSample->DEFAULT_WIDTH = 1920;
227 vDecSample->DEFAULT_HEIGHT = 1080;
228 vDecSample->DEFAULT_FRAME_RATE = 30;
229 vDecSample->SURFACE_OUTPUT = false;
230 vDecSample->autoSwitchSurface = false;
231 vDecSample->CreateSurface();
232 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
233 vDecSample->WaitForEOS();
234 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
235 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
236 }
237 }
238
239 /**
240 * @tc.number : API11_SURF_CHANGE_FUNC_008
241 * @tc.name : buffer model change in runing to flushed state
242 * @tc.desc : function test
243 */
244 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_008, TestSize.Level0)
245 {
246 if (!access("/system/lib64/media/", 0)) {
247 auto vDecSample = make_shared<VDecAPI11Sample>();
248 vDecSample->INP_DIR = INP_DIR_1080_30;
249 vDecSample->DEFAULT_WIDTH = 1920;
250 vDecSample->DEFAULT_HEIGHT = 1080;
251 vDecSample->DEFAULT_FRAME_RATE = 30;
252 vDecSample->SURFACE_OUTPUT = false;
253 vDecSample->autoSwitchSurface = false;
254 vDecSample->CreateSurface();
255 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
256 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
257 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
258 }
259 }
260
261 /**
262 * @tc.number : API11_SURF_CHANGE_FUNC_009
263 * @tc.name : buffer model change in flushed to runing state
264 * @tc.desc : function test
265 */
266 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_009, TestSize.Level0)
267 {
268 if (!access("/system/lib64/media/", 0)) {
269 auto vDecSample = make_shared<VDecAPI11Sample>();
270 vDecSample->INP_DIR = INP_DIR_1080_30;
271 vDecSample->DEFAULT_WIDTH = 1920;
272 vDecSample->DEFAULT_HEIGHT = 1080;
273 vDecSample->DEFAULT_FRAME_RATE = 30;
274 vDecSample->SURFACE_OUTPUT = false;
275 vDecSample->autoSwitchSurface = false;
276 vDecSample->CreateSurface();
277 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
278 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
279 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
280 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
281 }
282 }
283
284 /**
285 * @tc.number : API11_SURF_CHANGE_FUNC_012
286 * @tc.name : buffer model change in normal state
287 * @tc.desc : function test
288 */
289 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_012, TestSize.Level0)
290 {
291 if (!access("/system/lib64/media/", 0)) {
292 auto vDecSample = make_shared<VDecAPI11Sample>();
293 vDecSample->INP_DIR = INP_DIR_1080_30;
294 vDecSample->DEFAULT_WIDTH = 1920;
295 vDecSample->DEFAULT_HEIGHT = 1080;
296 vDecSample->DEFAULT_FRAME_RATE = 30;
297 vDecSample->SURFACE_OUTPUT = false;
298 vDecSample->autoSwitchSurface = false;
299 vDecSample->CreateSurface();
300 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
301 vDecSample->WaitForEOS();
302 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
303 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
304 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
305 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
306 }
307 }
308
309 /**
310 * @tc.number : API11_SURF_CHANGE_FUNC_013
311 * @tc.name : surf model change in config state
312 * @tc.desc : function test
313 */
314 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_013, TestSize.Level1)
315 {
316 if (!access("/system/lib64/media/", 0)) {
317 auto vDecSample = make_shared<VDecAPI11Sample>();
318 vDecSample->INP_DIR = INP_DIR_1080_30;
319 vDecSample->DEFAULT_WIDTH = 1920;
320 vDecSample->DEFAULT_HEIGHT = 1080;
321 vDecSample->DEFAULT_FRAME_RATE = 30;
322 vDecSample->SURFACE_OUTPUT = false;
323 vDecSample->autoSwitchSurface = false;
324 vDecSample->CreateSurface();
325 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
326 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
327 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
328 vDecSample->WaitForEOS();
329 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
330 }
331 }
332
333 /**
334 * @tc.number : API11_SURF_CHANGE_FUNC_014
335 * @tc.name : surf model change in config state
336 * @tc.desc : function test
337 */
338 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_014, TestSize.Level1)
339 {
340 if (!access("/system/lib64/media/", 0)) {
341 auto vDecSample = make_shared<VDecAPI11Sample>();
342 vDecSample->INP_DIR = INP_DIR_1080_30;
343 vDecSample->DEFAULT_WIDTH = 1920;
344 vDecSample->DEFAULT_HEIGHT = 1080;
345 vDecSample->DEFAULT_FRAME_RATE = 30;
346 vDecSample->SURFACE_OUTPUT = false;
347 vDecSample->autoSwitchSurface = false;
348 vDecSample->CreateSurface();
349 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));;
350 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
351 vDecSample->WaitForEOS();
352 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
353 }
354 }
355
356 /**
357 * @tc.number : API11_SURF_CHANGE_FUNC_015
358 * @tc.name : Two object repeat call setSurface fastly
359 * @tc.desc : function test
360 */
361 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_015, TestSize.Level0)
362 {
363 if (!access("/system/lib64/media/", 0)) {
364 auto vDecSample = make_shared<VDecAPI11Sample>();
365 vDecSample->INP_DIR = INP_DIR_1080_30;
366 vDecSample->DEFAULT_WIDTH = 1920;
367 vDecSample->DEFAULT_HEIGHT = 1080;
368 vDecSample->DEFAULT_FRAME_RATE = 30;
369 vDecSample->SURFACE_OUTPUT = true;
370 vDecSample->autoSwitchSurface = true;
371 vDecSample->sleepOnFPS = true;
372 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
373 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
374 vDecSample->WaitForEOS();
375
376 auto vDecSample_1 = make_shared<VDecAPI11Sample>();
377 vDecSample_1->INP_DIR = INP_DIR_1080_30;
378 vDecSample_1->DEFAULT_WIDTH = 1920;
379 vDecSample_1->DEFAULT_HEIGHT = 1080;
380 vDecSample_1->DEFAULT_FRAME_RATE = 30;
381 vDecSample_1->SURFACE_OUTPUT = true;
382 vDecSample_1->autoSwitchSurface = true;
383 vDecSample_1->sleepOnFPS = true;
384 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RunVideoDec_Surface(g_codecNameAvc));
385 ASSERT_EQ(AV_ERR_OK, vDecSample_1->SwitchSurface());
386 vDecSample_1->WaitForEOS();
387 }
388 }
389
390 /**
391 * @tc.number : API11_SURF_CHANGE_FUNC_016
392 * @tc.name : repeat call setSurface fastly 2 time
393 * @tc.desc : function test
394 */
395 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_016, TestSize.Level0)
396 {
397 if (!access("/system/lib64/media/", 0)) {
398 for (int i = 0; i < 2; i++) {
399 auto vDecSample = make_shared<VDecAPI11Sample>();
400 vDecSample->INP_DIR = INP_DIR_1080_30;
401 vDecSample->DEFAULT_WIDTH = 1920;
402 vDecSample->DEFAULT_HEIGHT = 1080;
403 vDecSample->DEFAULT_FRAME_RATE = 30;
404 vDecSample->SURFACE_OUTPUT = true;
405 vDecSample->autoSwitchSurface = true;
406 vDecSample->sleepOnFPS = true;
407 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
408 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
409 vDecSample->WaitForEOS();
410 }
411 }
412 }
413
414
415 /**
416 * @tc.number : VIDEO_SWDEC_FUNCTION_0200
417 * @tc.name : create nonexist decoder
418 * @tc.desc : function test
419 */
420 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0200, TestSize.Level1)
421 {
422 OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
423 ASSERT_EQ(nullptr, vdec_);
424 }
425
426 /**
427 * @tc.number : VIDEO_SWDEC_FUNCTION_0300
428 * @tc.name : test h264 decode buffer
429 * @tc.desc : function test
430 */
431 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0300, TestSize.Level0)
432 {
433 auto vDecSample = make_shared<VDecNdkSample>();
434 vDecSample->INP_DIR = INP_DIR_1080_30;
435 vDecSample->DEFAULT_WIDTH = 1920;
436 vDecSample->DEFAULT_HEIGHT = 1080;
437 vDecSample->DEFAULT_FRAME_RATE = 30;
438 vDecSample->SURFACE_OUTPUT = false;
439 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
440 vDecSample->WaitForEOS();
441 ASSERT_EQ(0, vDecSample->errCount);
442 }
443
444 /**
445 * @tc.number : VIDEO_SWDEC_FUNCTION_0400
446 * @tc.name : test h264 decode surface
447 * @tc.desc : function test
448 */
449 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
450 {
451 auto vDecSample = make_shared<VDecNdkSample>();
452 vDecSample->INP_DIR = INP_DIR_1080_30;
453 vDecSample->SURFACE_OUTPUT = true;
454 vDecSample->DEFAULT_WIDTH = 1920;
455 vDecSample->DEFAULT_HEIGHT = 1080;
456 vDecSample->DEFAULT_FRAME_RATE = 30;
457 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
458 vDecSample->WaitForEOS();
459 bool isVaild = false;
460 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
461 ASSERT_EQ(false, isVaild);
462 ASSERT_EQ(0, vDecSample->errCount);
463 }
464
465 /**
466 * @tc.number : VIDEO_SWDEC_FUNCTION_0700
467 * @tc.name : test set EOS when last frame
468 * @tc.desc : function test
469 */
470 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
471 {
472 auto vDecSample = make_shared<VDecNdkSample>();
473 vDecSample->INP_DIR = INP_DIR_1080_30;
474 vDecSample->DEFAULT_WIDTH = 1920;
475 vDecSample->DEFAULT_HEIGHT = 1080;
476 vDecSample->DEFAULT_FRAME_RATE = 30;
477 vDecSample->SURFACE_OUTPUT = false;
478 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
479 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
480 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
481 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
482 vDecSample->WaitForEOS();
483 ASSERT_EQ(0, vDecSample->errCount);
484 }
485
486 /**
487 * @tc.number : VIDEO_SWDEC_FUNCTION_0800
488 * @tc.name : test set EOS before last frame then stop
489 * @tc.desc : function test
490 */
491 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
492 {
493 auto vDecSample = make_shared<VDecNdkSample>();
494 vDecSample->INP_DIR = INP_DIR_1080_30;
495 vDecSample->DEFAULT_WIDTH = 1920;
496 vDecSample->DEFAULT_HEIGHT = 1080;
497 vDecSample->DEFAULT_FRAME_RATE = 30;
498 vDecSample->SURFACE_OUTPUT = false;
499 vDecSample->BEFORE_EOS_INPUT = true;
500 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
501 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
502 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
503 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
504 vDecSample->WaitForEOS();
505 ASSERT_EQ(0, vDecSample->errCount);
506 }
507 /**
508 * @tc.number : VIDEO_SWDEC_FUNCTION_4000
509 * @tc.name : test set EOS before last frame then stop surface
510 * @tc.desc : function test
511 */
512
513 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_4000, TestSize.Level1)
514 {
515 auto vDecSample = make_shared<VDecNdkSample>();
516 vDecSample->INP_DIR = INP_DIR_1080_30;
517 vDecSample->DEFAULT_WIDTH = 1920;
518 vDecSample->DEFAULT_HEIGHT = 1080;
519 vDecSample->DEFAULT_FRAME_RATE = 30;
520 vDecSample->SURFACE_OUTPUT = true;
521 vDecSample->BEFORE_EOS_INPUT = true;
522 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
523 vDecSample->WaitForEOS();
524 ASSERT_EQ(0, vDecSample->errCount);
525 }
526
527 /**
528 * @tc.number : VIDEO_SWDEC_FUNCTION_1000
529 * @tc.name : test reconfigure for new file with one decoder
530 * @tc.desc : function test
531 */
532 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
533 {
534 auto vDecSample = make_shared<VDecNdkSample>();
535 vDecSample->INP_DIR = INP_DIR_1080_30;
536 vDecSample->DEFAULT_WIDTH = 1920;
537 vDecSample->DEFAULT_HEIGHT = 1080;
538 vDecSample->DEFAULT_FRAME_RATE = 30;
539 vDecSample->SURFACE_OUTPUT = false;
540 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
541 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
542 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
543 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
544 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
545 vDecSample->WaitForEOS();
546 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
547 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
548 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
549 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
550 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
551 vDecSample->WaitForEOS();
552 ASSERT_EQ(0, vDecSample->errCount);
553 }
554
555 /**
556 * @tc.number : VIDEO_SWDEC_FUNCTION_1100
557 * @tc.name : test reconfigure for new file with the recreated decoder
558 * @tc.desc : function test
559 */
560 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
561 {
562 auto vDecSample = make_shared<VDecNdkSample>();
563 vDecSample->INP_DIR = INP_DIR_1080_30;
564 vDecSample->DEFAULT_WIDTH = 1920;
565 vDecSample->DEFAULT_HEIGHT = 1080;
566 vDecSample->DEFAULT_FRAME_RATE = 30;
567 vDecSample->SURFACE_OUTPUT = false;
568 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
569 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
570 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
571 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
572 vDecSample->WaitForEOS();
573 ASSERT_EQ(0, vDecSample->errCount);
574 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
575 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
576 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
577 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
578 vDecSample->WaitForEOS();
579 ASSERT_EQ(0, vDecSample->errCount);
580 }
581
582 /**
583 * @tc.number : VIDEO_SWDEC_FUNCTION_1200
584 * @tc.name : repeat start and stop 5 times before EOS
585 * @tc.desc : function test
586 */
587 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
588 {
589 auto vDecSample = make_shared<VDecNdkSample>();
590 vDecSample->INP_DIR = INP_DIR_1080_30;
591 vDecSample->DEFAULT_WIDTH = 1920;
592 vDecSample->DEFAULT_HEIGHT = 1080;
593 vDecSample->DEFAULT_FRAME_RATE = 30;
594 vDecSample->SURFACE_OUTPUT = false;
595 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
596 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
597 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
598 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
599 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
600 vDecSample->WaitForEOS();
601 ASSERT_EQ(0, vDecSample->errCount);
602 }
603
604 /**
605 * @tc.number : VIDEO_SWDEC_FUNCTION_1300
606 * @tc.name : repeat start and flush 5 times before EOS
607 * @tc.desc : function test
608 */
609 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
610 {
611 auto vDecSample = make_shared<VDecNdkSample>();
612 vDecSample->INP_DIR = INP_DIR_1080_30;
613 vDecSample->DEFAULT_WIDTH = 1920;
614 vDecSample->DEFAULT_HEIGHT = 1080;
615 vDecSample->DEFAULT_FRAME_RATE = 30;
616 vDecSample->SURFACE_OUTPUT = false;
617 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
618 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
619 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
620 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
621 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
622 vDecSample->WaitForEOS();
623 ASSERT_EQ(0, vDecSample->errCount);
624 }
625
626 /**
627 * @tc.number : VIDEO_SWDEC_FUNCTION_1400
628 * @tc.name : set larger width and height
629 * @tc.desc : function test
630 */
631 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1400, TestSize.Level2)
632 {
633 auto vDecSample = make_shared<VDecNdkSample>();
634 vDecSample->INP_DIR = INP_DIR_720_30;
635 vDecSample->DEFAULT_WIDTH = 1920;
636 vDecSample->DEFAULT_HEIGHT = 1080;
637 vDecSample->DEFAULT_FRAME_RATE = 30;
638 vDecSample->SURFACE_OUTPUT = false;
639 vDecSample->checkOutPut = false;
640 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
641 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
642 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
643 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
644 vDecSample->WaitForEOS();
645 ASSERT_EQ(0, vDecSample->errCount);
646 }
647
648 /**
649 * @tc.number : VIDEO_SWDEC_FUNCTION_1500
650 * @tc.name : set the width and height to a samller value
651 * @tc.desc : function test
652 */
653 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1500, TestSize.Level2)
654 {
655 auto vDecSample = make_shared<VDecNdkSample>();
656 vDecSample->INP_DIR = INP_DIR_1080_30;
657 vDecSample->DEFAULT_WIDTH = 1280;
658 vDecSample->DEFAULT_HEIGHT = 720;
659 vDecSample->DEFAULT_FRAME_RATE = 30;
660 vDecSample->SURFACE_OUTPUT = false;
661 vDecSample->checkOutPut = false;
662 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
663 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
664 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
665 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
666 vDecSample->WaitForEOS();
667 ASSERT_EQ(0, vDecSample->errCount);
668 }
669
670 /**
671 * @tc.number : VIDEO_SWDEC_FUNCTION_1600
672 * @tc.name : resolution change
673 * @tc.desc : function test
674 */
675 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1600, TestSize.Level2)
676 {
677 auto vDecSample = make_shared<VDecNdkSample>();
678 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
679 vDecSample->DEFAULT_WIDTH = 1104;
680 vDecSample->DEFAULT_HEIGHT = 622;
681 vDecSample->DEFAULT_FRAME_RATE = 30;
682 vDecSample->SURFACE_OUTPUT = false;
683 vDecSample->checkOutPut = false;
684 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
685 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
686 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
687 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
688 vDecSample->WaitForEOS();
689 ASSERT_EQ(0, vDecSample->errCount);
690 }
691
692 /**
693 * @tc.number : VIDEO_SWDEC_FUNCTION_1700
694 * @tc.name : decode h264 stream ,output pixel format is nv21
695 * @tc.desc : function test
696 */
697 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1700, TestSize.Level2)
698 {
699 auto vDecSample = make_shared<VDecNdkSample>();
700 vDecSample->INP_DIR = INP_DIR_1080_30;
701 vDecSample->DEFAULT_WIDTH = 1920;
702 vDecSample->DEFAULT_HEIGHT = 1080;
703 vDecSample->DEFAULT_FRAME_RATE = 30;
704 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
705 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
706 vDecSample->WaitForEOS();
707 ASSERT_EQ(0, vDecSample->errCount);
708 }
709
710 /**
711 * @tc.number : VIDEO_SWDEC_FUNCTION_1800
712 * @tc.name : decode h264 stream ,output pixel format is rgba
713 * @tc.desc : function test
714 */
715 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1800, TestSize.Level2)
716 {
717 auto vDecSample = make_shared<VDecNdkSample>();
718 vDecSample->INP_DIR = INP_DIR_1080_30;
719 vDecSample->DEFAULT_WIDTH = 1920;
720 vDecSample->DEFAULT_HEIGHT = 1080;
721 vDecSample->DEFAULT_FRAME_RATE = 30;
722 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
723 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
724 vDecSample->WaitForEOS();
725 ASSERT_EQ(0, vDecSample->errCount);
726 }
727
728 /**
729 * @tc.number : VIDEO_SWDEC_FUNCTION_ATTIME_0010
730 * @tc.name : test h264 asyn decode surface,use at time
731 * @tc.desc : function test
732 */
733 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_ATTIME_0010, TestSize.Level0)
734 {
735 auto vDecSample = make_shared<VDecAPI11Sample>();
736 vDecSample->INP_DIR = INP_DIR_720_30;
737 vDecSample->DEFAULT_WIDTH = 1280;
738 vDecSample->DEFAULT_HEIGHT = 720;
739 vDecSample->DEFAULT_FRAME_RATE = 30;
740 vDecSample->SURFACE_OUTPUT = true;
741 vDecSample->rsAtTime = true;
742 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
743 vDecSample->WaitForEOS();
744 ASSERT_EQ(0, vDecSample->errCount);
745 }
746
747 /**
748 * @tc.number : VIDEO_SWDEC_FUNCTION_1900
749 * @tc.name : Increase frame rate judgment
750 * @tc.desc : function test
751 */
752 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1910, TestSize.Level2)
753 {
754 auto vDecSample = make_shared<VDecAPI11Sample>();
755 vDecSample->INP_DIR = INP_DIR_720_30;
756 vDecSample->OUT_DIR = "/data/test/media/SW_720_30.yuv";
757 vDecSample->DEFAULT_WIDTH = 1920;
758 vDecSample->DEFAULT_HEIGHT = 1080;
759 vDecSample->DEFAULT_FRAME_RATE = 30;
760 vDecSample->SURFACE_OUTPUT = false;
761 vDecSample->outputYuvFlag = true;
762 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
763 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
764 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
765 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
766 vDecSample->WaitForEOS();
767 ASSERT_EQ(101, vDecSample->outFrameCount);
768 ASSERT_EQ(0, vDecSample->errCount);
769 }
770
771 /**
772 * @tc.number : VIDEO_SWDEC_RESOLUTION_PROFILE_0010
773 * @tc.name : Resolution and profile change
774 * @tc.desc : function test
775 */
776 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_RESOLUTION_PROFILE_0010, TestSize.Level2)
777 {
778 auto vDecSample = make_shared<VDecAPI11Sample>();
779 vDecSample->INP_DIR = "/data/test/media/profResoChange.h264";
780 vDecSample->DEFAULT_WIDTH = 1920;
781 vDecSample->DEFAULT_HEIGHT = 1080;
782 vDecSample->DEFAULT_FRAME_RATE = 30;
783 vDecSample->SURFACE_OUTPUT = false;
784 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
785 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
786 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
787 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
788 vDecSample->WaitForEOS();
789 ASSERT_EQ(350, vDecSample->outFrameCount);
790 ASSERT_EQ(0, vDecSample->errCount);
791 }
792
793 /**
794 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0010
795 * @tc.name : 264同步软解输出nv12
796 * @tc.desc : function test
797 */
798 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0010, TestSize.Level1)
799 {
800 if (cap_avc != nullptr) {
801 auto vDecSample = make_shared<VDecAPI11Sample>();
802 vDecSample->INP_DIR = INP_DIR_1080_30;
803 vDecSample->DEFAULT_WIDTH = 1920;
804 vDecSample->DEFAULT_HEIGHT = 1080;
805 vDecSample->DEFAULT_FRAME_RATE = 30;
806 vDecSample->enbleSyncMode = 1;
807 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
808 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
809 vDecSample->sleepOnFPS = true;
810 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
811 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
812 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
813 vDecSample->WaitForEOS();
814 ASSERT_EQ(0, vDecSample->errCount);
815 }
816 }
817
818 /**
819 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0020
820 * @tc.name : 264同步软解输出nv21
821 * @tc.desc : function test
822 */
823 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0020, TestSize.Level0)
824 {
825 if (cap_avc != nullptr) {
826 auto vDecSample = make_shared<VDecAPI11Sample>();
827 vDecSample->INP_DIR = INP_DIR_1080_30;
828 vDecSample->DEFAULT_WIDTH = 1920;
829 vDecSample->DEFAULT_HEIGHT = 1080;
830 vDecSample->DEFAULT_FRAME_RATE = 30;
831 vDecSample->enbleSyncMode = 1;
832 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
833 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
834 vDecSample->sleepOnFPS = true;
835 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
836 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
837 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
838 vDecSample->WaitForEOS();
839 ASSERT_EQ(0, vDecSample->errCount);
840 }
841 }
842
843 /**
844 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0030
845 * @tc.name : 264同步软解输出surface
846 * @tc.desc : function test
847 */
848 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0030, TestSize.Level1)
849 {
850 if (cap_avc != nullptr) {
851 auto vDecSample = make_shared<VDecAPI11Sample>();
852 vDecSample->INP_DIR = INP_DIR_1080_30;
853 vDecSample->DEFAULT_WIDTH = 1920;
854 vDecSample->DEFAULT_HEIGHT = 1080;
855 vDecSample->DEFAULT_FRAME_RATE = 30;
856 vDecSample->SURFACE_OUTPUT = true;
857 vDecSample->enbleSyncMode = 1;
858 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
859 vDecSample->sleepOnFPS = true;
860 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
861 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
862 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
863 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
864 vDecSample->WaitForEOS();
865 ASSERT_EQ(0, vDecSample->errCount);
866 }
867 }
868
869 /**
870 * @tc.number : VIDEO_DECODE_SYNC_SW264_FUNC_0040
871 * @tc.name : 264同步软解输出rgba
872 * @tc.desc : function test
873 */
874 HWTEST_F(SwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW264_FUNC_0040, TestSize.Level1)
875 {
876 if (cap_avc != nullptr) {
877 auto vDecSample = make_shared<VDecAPI11Sample>();
878 vDecSample->INP_DIR = INP_DIR_1080_30;
879 vDecSample->DEFAULT_WIDTH = 1920;
880 vDecSample->DEFAULT_HEIGHT = 1080;
881 vDecSample->DEFAULT_FRAME_RATE = 30;
882 vDecSample->enbleSyncMode = 1;
883 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_RGBA;
884 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
885 vDecSample->sleepOnFPS = true;
886 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
887 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
888 ASSERT_EQ(AV_ERR_OK, vDecSample->StartSyncVideoDecoder());
889 vDecSample->WaitForEOS();
890 ASSERT_EQ(0, vDecSample->errCount);
891 }
892 }
893
894 /**
895 * @tc.number : VIDEO_SWDECODE_BLANK_FRAME_0010
896 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h264 swd
897 * @tc.desc : function test
898 */
899 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDECODE_BLANK_FRAME_0010, TestSize.Level2)
900 {
901 if (cap_avc != nullptr) {
902 auto vDecSample = make_shared<VDecAPI11Sample>();
903 vDecSample->INP_DIR = INP_DIR_1080_30;
904 vDecSample->DEFAULT_WIDTH = 1920;
905 vDecSample->DEFAULT_HEIGHT = 1080;
906 vDecSample->DEFAULT_FRAME_RATE = 30;
907 vDecSample->enbleBlankFrame = 1;
908 vDecSample->SURFACE_OUTPUT = false;
909 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
910 vDecSample->WaitForEOS();
911 ASSERT_EQ(0, vDecSample->errCount);
912 }
913 }
914
915 /**
916 * @tc.number : VIDEO_SWDECODE_BLANK_FRAME_0020
917 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h264 swd, surface
918 * @tc.desc : function test
919 */
920 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDECODE_BLANK_FRAME_0020, TestSize.Level2)
921 {
922 if (cap_avc != nullptr) {
923 auto vDecSample = make_shared<VDecAPI11Sample>();
924 vDecSample->INP_DIR = INP_DIR_1080_30;
925 vDecSample->DEFAULT_WIDTH = 1920;
926 vDecSample->DEFAULT_HEIGHT = 1080;
927 vDecSample->DEFAULT_FRAME_RATE = 30;
928 vDecSample->enbleBlankFrame = 1;
929 vDecSample->SURFACE_OUTPUT = true;
930 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
931 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
932 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
933 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
934 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
935 vDecSample->WaitForEOS();
936 ASSERT_EQ(0, vDecSample->errCount);
937 }
938 }
939 } // namespace