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 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
259 }
260 }
261
262 /**
263 * @tc.number : API11_SURF_CHANGE_FUNC_009
264 * @tc.name : buffer model change in flushed to runing state
265 * @tc.desc : function test
266 */
267 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_009, TestSize.Level0)
268 {
269 if (!access("/system/lib64/media/", 0)) {
270 auto vDecSample = make_shared<VDecAPI11Sample>();
271 vDecSample->INP_DIR = INP_DIR_1080_30;
272 vDecSample->DEFAULT_WIDTH = 1920;
273 vDecSample->DEFAULT_HEIGHT = 1080;
274 vDecSample->DEFAULT_FRAME_RATE = 30;
275 vDecSample->SURFACE_OUTPUT = false;
276 vDecSample->autoSwitchSurface = false;
277 vDecSample->CreateSurface();
278 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
279 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
280 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
281 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
282 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
283 }
284 }
285
286 /**
287 * @tc.number : API11_SURF_CHANGE_FUNC_012
288 * @tc.name : buffer model change in normal state
289 * @tc.desc : function test
290 */
291 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_012, TestSize.Level0)
292 {
293 if (!access("/system/lib64/media/", 0)) {
294 auto vDecSample = make_shared<VDecAPI11Sample>();
295 vDecSample->INP_DIR = INP_DIR_1080_30;
296 vDecSample->DEFAULT_WIDTH = 1920;
297 vDecSample->DEFAULT_HEIGHT = 1080;
298 vDecSample->DEFAULT_FRAME_RATE = 30;
299 vDecSample->SURFACE_OUTPUT = false;
300 vDecSample->autoSwitchSurface = false;
301 vDecSample->CreateSurface();
302 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameAvc));
303 vDecSample->WaitForEOS();
304 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
305 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
306 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
307 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
308 }
309 }
310
311 /**
312 * @tc.number : API11_SURF_CHANGE_FUNC_013
313 * @tc.name : surf model change in config state
314 * @tc.desc : function test
315 */
316 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_013, TestSize.Level1)
317 {
318 if (!access("/system/lib64/media/", 0)) {
319 auto vDecSample = make_shared<VDecAPI11Sample>();
320 vDecSample->INP_DIR = INP_DIR_1080_30;
321 vDecSample->DEFAULT_WIDTH = 1920;
322 vDecSample->DEFAULT_HEIGHT = 1080;
323 vDecSample->DEFAULT_FRAME_RATE = 30;
324 vDecSample->SURFACE_OUTPUT = false;
325 vDecSample->autoSwitchSurface = false;
326 vDecSample->CreateSurface();
327 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));
328 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
329 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
330 vDecSample->WaitForEOS();
331 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
332 }
333 }
334
335 /**
336 * @tc.number : API11_SURF_CHANGE_FUNC_014
337 * @tc.name : surf model change in config state
338 * @tc.desc : function test
339 */
340 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_014, TestSize.Level1)
341 {
342 if (!access("/system/lib64/media/", 0)) {
343 auto vDecSample = make_shared<VDecAPI11Sample>();
344 vDecSample->INP_DIR = INP_DIR_1080_30;
345 vDecSample->DEFAULT_WIDTH = 1920;
346 vDecSample->DEFAULT_HEIGHT = 1080;
347 vDecSample->DEFAULT_FRAME_RATE = 30;
348 vDecSample->SURFACE_OUTPUT = false;
349 vDecSample->autoSwitchSurface = false;
350 vDecSample->CreateSurface();
351 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameAvc));;
352 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
353 vDecSample->WaitForEOS();
354 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
355 }
356 }
357
358 /**
359 * @tc.number : API11_SURF_CHANGE_FUNC_015
360 * @tc.name : Two object repeat call setSurface fastly
361 * @tc.desc : function test
362 */
363 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_015, TestSize.Level0)
364 {
365 if (!access("/system/lib64/media/", 0)) {
366 auto vDecSample = make_shared<VDecAPI11Sample>();
367 vDecSample->INP_DIR = INP_DIR_1080_30;
368 vDecSample->DEFAULT_WIDTH = 1920;
369 vDecSample->DEFAULT_HEIGHT = 1080;
370 vDecSample->DEFAULT_FRAME_RATE = 30;
371 vDecSample->SURFACE_OUTPUT = true;
372 vDecSample->autoSwitchSurface = true;
373 vDecSample->sleepOnFPS = true;
374 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
375 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
376 vDecSample->WaitForEOS();
377
378 auto vDecSample_1 = make_shared<VDecAPI11Sample>();
379 vDecSample_1->INP_DIR = INP_DIR_1080_30;
380 vDecSample_1->DEFAULT_WIDTH = 1920;
381 vDecSample_1->DEFAULT_HEIGHT = 1080;
382 vDecSample_1->DEFAULT_FRAME_RATE = 30;
383 vDecSample_1->SURFACE_OUTPUT = true;
384 vDecSample_1->autoSwitchSurface = true;
385 vDecSample_1->sleepOnFPS = true;
386 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RunVideoDec_Surface(g_codecNameAvc));
387 ASSERT_EQ(AV_ERR_OK, vDecSample_1->SwitchSurface());
388 vDecSample_1->WaitForEOS();
389 }
390 }
391
392 /**
393 * @tc.number : API11_SURF_CHANGE_FUNC_016
394 * @tc.name : repeat call setSurface fastly 2 time
395 * @tc.desc : function test
396 */
397 HWTEST_F(SwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_016, TestSize.Level0)
398 {
399 if (!access("/system/lib64/media/", 0)) {
400 for (int i = 0; i < 2; i++) {
401 auto vDecSample = make_shared<VDecAPI11Sample>();
402 vDecSample->INP_DIR = INP_DIR_1080_30;
403 vDecSample->DEFAULT_WIDTH = 1920;
404 vDecSample->DEFAULT_HEIGHT = 1080;
405 vDecSample->DEFAULT_FRAME_RATE = 30;
406 vDecSample->SURFACE_OUTPUT = true;
407 vDecSample->autoSwitchSurface = true;
408 vDecSample->sleepOnFPS = true;
409 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameAvc));
410 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
411 vDecSample->WaitForEOS();
412 }
413 }
414 }
415
416
417 /**
418 * @tc.number : VIDEO_SWDEC_FUNCTION_0200
419 * @tc.name : create nonexist decoder
420 * @tc.desc : function test
421 */
422 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0200, TestSize.Level1)
423 {
424 OH_AVCodec *vdec_ = OH_VideoDecoder_CreateByName("OMX.h264.decode.111.222.333");
425 ASSERT_EQ(nullptr, vdec_);
426 }
427
428 /**
429 * @tc.number : VIDEO_SWDEC_FUNCTION_0300
430 * @tc.name : test h264 decode buffer
431 * @tc.desc : function test
432 */
433 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0300, TestSize.Level0)
434 {
435 auto vDecSample = make_shared<VDecNdkSample>();
436 vDecSample->INP_DIR = INP_DIR_1080_30;
437 vDecSample->DEFAULT_WIDTH = 1920;
438 vDecSample->DEFAULT_HEIGHT = 1080;
439 vDecSample->DEFAULT_FRAME_RATE = 30;
440 vDecSample->SURFACE_OUTPUT = false;
441 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
442 vDecSample->WaitForEOS();
443 ASSERT_EQ(0, vDecSample->errCount);
444 }
445
446 /**
447 * @tc.number : VIDEO_SWDEC_FUNCTION_0400
448 * @tc.name : test h264 decode surface
449 * @tc.desc : function test
450 */
451 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
452 {
453 auto vDecSample = make_shared<VDecNdkSample>();
454 vDecSample->INP_DIR = INP_DIR_1080_30;
455 vDecSample->SURFACE_OUTPUT = true;
456 vDecSample->DEFAULT_WIDTH = 1920;
457 vDecSample->DEFAULT_HEIGHT = 1080;
458 vDecSample->DEFAULT_FRAME_RATE = 30;
459 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
460 vDecSample->WaitForEOS();
461 bool isVaild = false;
462 OH_VideoDecoder_IsValid(vDecSample->vdec_, &isVaild);
463 ASSERT_EQ(false, isVaild);
464 ASSERT_EQ(0, vDecSample->errCount);
465 }
466
467 /**
468 * @tc.number : VIDEO_SWDEC_FUNCTION_0700
469 * @tc.name : test set EOS when last frame
470 * @tc.desc : function test
471 */
472 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
473 {
474 auto vDecSample = make_shared<VDecNdkSample>();
475 vDecSample->INP_DIR = INP_DIR_1080_30;
476 vDecSample->DEFAULT_WIDTH = 1920;
477 vDecSample->DEFAULT_HEIGHT = 1080;
478 vDecSample->DEFAULT_FRAME_RATE = 30;
479 vDecSample->SURFACE_OUTPUT = false;
480 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
481 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
482 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
483 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
484 vDecSample->WaitForEOS();
485 ASSERT_EQ(0, vDecSample->errCount);
486 }
487
488 /**
489 * @tc.number : VIDEO_SWDEC_FUNCTION_0800
490 * @tc.name : test set EOS before last frame then stop
491 * @tc.desc : function test
492 */
493 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
494 {
495 auto vDecSample = make_shared<VDecNdkSample>();
496 vDecSample->INP_DIR = INP_DIR_1080_30;
497 vDecSample->DEFAULT_WIDTH = 1920;
498 vDecSample->DEFAULT_HEIGHT = 1080;
499 vDecSample->DEFAULT_FRAME_RATE = 30;
500 vDecSample->SURFACE_OUTPUT = false;
501 vDecSample->BEFORE_EOS_INPUT = true;
502 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
503 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
504 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
505 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
506 vDecSample->WaitForEOS();
507 ASSERT_EQ(0, vDecSample->errCount);
508 }
509 /**
510 * @tc.number : VIDEO_SWDEC_FUNCTION_4000
511 * @tc.name : test set EOS before last frame then stop surface
512 * @tc.desc : function test
513 */
514
515 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_4000, TestSize.Level1)
516 {
517 auto vDecSample = make_shared<VDecNdkSample>();
518 vDecSample->INP_DIR = INP_DIR_1080_30;
519 vDecSample->DEFAULT_WIDTH = 1920;
520 vDecSample->DEFAULT_HEIGHT = 1080;
521 vDecSample->DEFAULT_FRAME_RATE = 30;
522 vDecSample->SURFACE_OUTPUT = true;
523 vDecSample->BEFORE_EOS_INPUT = true;
524 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
525 vDecSample->WaitForEOS();
526 ASSERT_EQ(0, vDecSample->errCount);
527 }
528
529 /**
530 * @tc.number : VIDEO_SWDEC_FUNCTION_1000
531 * @tc.name : test reconfigure for new file with one decoder
532 * @tc.desc : function test
533 */
534 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
535 {
536 auto vDecSample = make_shared<VDecNdkSample>();
537 vDecSample->INP_DIR = INP_DIR_1080_30;
538 vDecSample->DEFAULT_WIDTH = 1920;
539 vDecSample->DEFAULT_HEIGHT = 1080;
540 vDecSample->DEFAULT_FRAME_RATE = 30;
541 vDecSample->SURFACE_OUTPUT = false;
542 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
543 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
544 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
545 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
546 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
547 vDecSample->WaitForEOS();
548 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
549 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
550 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
551 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
552 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
553 vDecSample->WaitForEOS();
554 ASSERT_EQ(0, vDecSample->errCount);
555 }
556
557 /**
558 * @tc.number : VIDEO_SWDEC_FUNCTION_1100
559 * @tc.name : test reconfigure for new file with the recreated decoder
560 * @tc.desc : function test
561 */
562 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
563 {
564 auto vDecSample = make_shared<VDecNdkSample>();
565 vDecSample->INP_DIR = INP_DIR_1080_30;
566 vDecSample->DEFAULT_WIDTH = 1920;
567 vDecSample->DEFAULT_HEIGHT = 1080;
568 vDecSample->DEFAULT_FRAME_RATE = 30;
569 vDecSample->SURFACE_OUTPUT = false;
570 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
571 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
572 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
573 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
574 vDecSample->WaitForEOS();
575 ASSERT_EQ(0, vDecSample->errCount);
576 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
577 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
578 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
579 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
580 vDecSample->WaitForEOS();
581 ASSERT_EQ(0, vDecSample->errCount);
582 }
583
584 /**
585 * @tc.number : VIDEO_SWDEC_FUNCTION_1200
586 * @tc.name : repeat start and stop 5 times before EOS
587 * @tc.desc : function test
588 */
589 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
590 {
591 auto vDecSample = make_shared<VDecNdkSample>();
592 vDecSample->INP_DIR = INP_DIR_1080_30;
593 vDecSample->DEFAULT_WIDTH = 1920;
594 vDecSample->DEFAULT_HEIGHT = 1080;
595 vDecSample->DEFAULT_FRAME_RATE = 30;
596 vDecSample->SURFACE_OUTPUT = false;
597 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 5;
598 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
599 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
600 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
601 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
602 vDecSample->WaitForEOS();
603 ASSERT_EQ(0, vDecSample->errCount);
604 }
605
606 /**
607 * @tc.number : VIDEO_SWDEC_FUNCTION_1300
608 * @tc.name : repeat start and flush 5 times before EOS
609 * @tc.desc : function test
610 */
611 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
612 {
613 auto vDecSample = make_shared<VDecNdkSample>();
614 vDecSample->INP_DIR = INP_DIR_1080_30;
615 vDecSample->DEFAULT_WIDTH = 1920;
616 vDecSample->DEFAULT_HEIGHT = 1080;
617 vDecSample->DEFAULT_FRAME_RATE = 30;
618 vDecSample->SURFACE_OUTPUT = false;
619 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
620 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
621 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
622 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
623 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
624 vDecSample->WaitForEOS();
625 ASSERT_EQ(0, vDecSample->errCount);
626 }
627
628 /**
629 * @tc.number : VIDEO_SWDEC_FUNCTION_1400
630 * @tc.name : set larger width and height
631 * @tc.desc : function test
632 */
633 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1400, TestSize.Level2)
634 {
635 auto vDecSample = make_shared<VDecNdkSample>();
636 vDecSample->INP_DIR = INP_DIR_720_30;
637 vDecSample->DEFAULT_WIDTH = 1920;
638 vDecSample->DEFAULT_HEIGHT = 1080;
639 vDecSample->DEFAULT_FRAME_RATE = 30;
640 vDecSample->SURFACE_OUTPUT = false;
641 vDecSample->checkOutPut = false;
642 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
643 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
644 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
645 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
646 vDecSample->WaitForEOS();
647 ASSERT_EQ(0, vDecSample->errCount);
648 }
649
650 /**
651 * @tc.number : VIDEO_SWDEC_FUNCTION_1500
652 * @tc.name : set the width and height to a samller value
653 * @tc.desc : function test
654 */
655 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1500, TestSize.Level2)
656 {
657 auto vDecSample = make_shared<VDecNdkSample>();
658 vDecSample->INP_DIR = INP_DIR_1080_30;
659 vDecSample->DEFAULT_WIDTH = 1280;
660 vDecSample->DEFAULT_HEIGHT = 720;
661 vDecSample->DEFAULT_FRAME_RATE = 30;
662 vDecSample->SURFACE_OUTPUT = false;
663 vDecSample->checkOutPut = false;
664 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
665 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
666 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
667 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
668 vDecSample->WaitForEOS();
669 ASSERT_EQ(0, vDecSample->errCount);
670 }
671
672 /**
673 * @tc.number : VIDEO_SWDEC_FUNCTION_1600
674 * @tc.name : resolution change
675 * @tc.desc : function test
676 */
677 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1600, TestSize.Level2)
678 {
679 auto vDecSample = make_shared<VDecNdkSample>();
680 vDecSample->INP_DIR = "/data/test/media/resolutionChange.h264";
681 vDecSample->DEFAULT_WIDTH = 1104;
682 vDecSample->DEFAULT_HEIGHT = 622;
683 vDecSample->DEFAULT_FRAME_RATE = 30;
684 vDecSample->SURFACE_OUTPUT = false;
685 vDecSample->checkOutPut = false;
686 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
687 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
688 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
689 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
690 vDecSample->WaitForEOS();
691 ASSERT_EQ(0, vDecSample->errCount);
692 }
693
694 /**
695 * @tc.number : VIDEO_SWDEC_FUNCTION_1700
696 * @tc.name : decode h264 stream ,output pixel format is nv21
697 * @tc.desc : function test
698 */
699 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1700, TestSize.Level2)
700 {
701 auto vDecSample = make_shared<VDecNdkSample>();
702 vDecSample->INP_DIR = INP_DIR_1080_30;
703 vDecSample->DEFAULT_WIDTH = 1920;
704 vDecSample->DEFAULT_HEIGHT = 1080;
705 vDecSample->DEFAULT_FRAME_RATE = 30;
706 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21;
707 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
708 vDecSample->WaitForEOS();
709 ASSERT_EQ(0, vDecSample->errCount);
710 }
711
712 /**
713 * @tc.number : VIDEO_SWDEC_FUNCTION_1800
714 * @tc.name : decode h264 stream ,output pixel format is rgba
715 * @tc.desc : function test
716 */
717 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1800, TestSize.Level2)
718 {
719 auto vDecSample = make_shared<VDecNdkSample>();
720 vDecSample->INP_DIR = INP_DIR_1080_30;
721 vDecSample->DEFAULT_WIDTH = 1920;
722 vDecSample->DEFAULT_HEIGHT = 1080;
723 vDecSample->DEFAULT_FRAME_RATE = 30;
724 vDecSample->DEFAULT_PIXEL_FORMAT = AV_PIXEL_FORMAT_RGBA;
725 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec("OH.Media.Codec.Decoder.Video.AVC"));
726 vDecSample->WaitForEOS();
727 ASSERT_EQ(0, vDecSample->errCount);
728 }
729
730 /**
731 * @tc.number : VIDEO_SWDEC_FUNCTION_ATTIME_0010
732 * @tc.name : test h264 asyn decode surface,use at time
733 * @tc.desc : function test
734 */
735 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_ATTIME_0010, TestSize.Level0)
736 {
737 auto vDecSample = make_shared<VDecAPI11Sample>();
738 vDecSample->INP_DIR = INP_DIR_720_30;
739 vDecSample->DEFAULT_WIDTH = 1280;
740 vDecSample->DEFAULT_HEIGHT = 720;
741 vDecSample->DEFAULT_FRAME_RATE = 30;
742 vDecSample->SURFACE_OUTPUT = true;
743 vDecSample->rsAtTime = true;
744 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface("OH.Media.Codec.Decoder.Video.AVC"));
745 vDecSample->WaitForEOS();
746 ASSERT_EQ(0, vDecSample->errCount);
747 }
748
749 /**
750 * @tc.number : VIDEO_SWDEC_FUNCTION_1900
751 * @tc.name : Increase frame rate judgment
752 * @tc.desc : function test
753 */
754 HWTEST_F(SwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1910, TestSize.Level2)
755 {
756 auto vDecSample = make_shared<VDecAPI11Sample>();
757 vDecSample->INP_DIR = INP_DIR_720_30;
758 vDecSample->OUT_DIR = "/data/test/media/SW_720_30.yuv";
759 vDecSample->DEFAULT_WIDTH = 1920;
760 vDecSample->DEFAULT_HEIGHT = 1080;
761 vDecSample->DEFAULT_FRAME_RATE = 30;
762 vDecSample->SURFACE_OUTPUT = false;
763 vDecSample->outputYuvFlag = true;
764 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder("OH.Media.Codec.Decoder.Video.AVC"));
765 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
766 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
767 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
768 vDecSample->WaitForEOS();
769 ASSERT_EQ(101, vDecSample->outFrameCount);
770 ASSERT_EQ(0, vDecSample->errCount);
771 }
772 } // namespace