1 /*
2 * Copyright (C) 2024 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 "native_avformat.h"
21 #include "videodec_api11_sample.h"
22 #include "native_avcodec_base.h"
23 #include "avcodec_codec_name.h"
24 #include "native_avcapability.h"
25
26 using namespace std;
27 using namespace OHOS;
28 using namespace OHOS::Media;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Media {
33 class HevcSwdecFuncNdkTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 void Release();
40 int32_t Stop();
41
42 protected:
43 const char *INP_DIR_1080_30 = "/data/test/media/1920_1080_30.h265";
44 const char *INP_DIR_144 = "/data/test/media/176_144_Main10.h265";
45 const char *INP_DIR_64 = "/data/test/media/64_64_Main.h265";
46 const char *INP_DIR_1158 = "/data/test/media/1544_1158_Rext_gray.h265";
47 const char *INP_DIR_1440 = "/data/test/media/1920_1440_Main_HEIF.h265";
48 const char *INP_DIR_1022 = "/data/test/media/1858_1022_Main.h265";
49 const char *INP_DIR_71 = "/data/test/media/95_71_Rext_gray.h265";
50 const char *INP_DIR_var = "/data/test/media/95_71_Rext_gray.h265";
51 const char *INP_DIR_1080_64_var = "/data/test/media/1920_1080_64_64_var.h265";
52 };
53 } // namespace Media
54 } // namespace OHOS
55
56
57 int32_t g_reliCount100 = 50;
58 int32_t g_reliCount2 = 1;
59 namespace {
60 OH_AVCodec *vdec_ = NULL;
61 OH_AVFormat *format;
62 static OH_AVCapability *cap_hevc = nullptr;
63 static string g_codecNameHevc = "";
64 constexpr int32_t DEFAULT_WIDTH = 1920;
65 constexpr int32_t DEFAULT_HEIGHT = 1080;
66 } // namespace
67
SetUpTestCase()68 void HevcSwdecFuncNdkTest::SetUpTestCase()
69 {
70 cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
71 g_codecNameHevc = OH_AVCapability_GetName(cap_hevc);
72 cout << "g_codecNameHevc: " << g_codecNameHevc << endl;
73 }
74
TearDownTestCase()75 void HevcSwdecFuncNdkTest::TearDownTestCase() {}
SetUp()76 void HevcSwdecFuncNdkTest::SetUp() {}
TearDown()77 void HevcSwdecFuncNdkTest::TearDown() {}
78
79 namespace {
80 /**
81 * @tc.number : VIDEO_SWDEC_FUNCTION_0320
82 * @tc.name : test h265 decode buffer pixel foramt nv12
83 * @tc.desc : function test
84 */
85 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0320, TestSize.Level0)
86 {
87 if (!access("/system/lib64/media/", 0)) {
88 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
89 vDecSample->INP_DIR = INP_DIR_1080_30;
90 vDecSample->DEFAULT_WIDTH = 1920;
91 vDecSample->DEFAULT_HEIGHT = 1080;
92 vDecSample->DEFAULT_FRAME_RATE = 30;
93 vDecSample->SF_OUTPUT = false;
94 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
95 vDecSample->WaitForEOS();
96 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
97 }
98 }
99
100 /**
101 * @tc.number : VIDEO_SWDEC_FUNCTION_0320
102 * @tc.name : test h265 decode buffer pixel foramt nv21
103 * @tc.desc : function test
104 */
105 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0330, TestSize.Level0)
106 {
107 if (!access("/system/lib64/media/", 0)) {
108 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
109 vDecSample->INP_DIR = INP_DIR_1080_30;
110 vDecSample->DEFAULT_WIDTH = 1920;
111 vDecSample->DEFAULT_HEIGHT = 1080;
112 vDecSample->DEFAULT_FRAME_RATE = 30;
113 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
114 vDecSample->SF_OUTPUT = false;
115 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
116 vDecSample->WaitForEOS();
117 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
118 }
119 }
120
121 /**
122 * @tc.number : VIDEO_SWDEC_FUNCTION_0400
123 * @tc.name : test h265 decode surface, pixel foramt nv12
124 * @tc.desc : function test
125 */
126 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
127 {
128 if (!access("/system/lib64/media/", 0)) {
129 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
130 vDecSample->INP_DIR = INP_DIR_1080_30;
131 vDecSample->SF_OUTPUT = true;
132 vDecSample->DEFAULT_WIDTH = 1920;
133 vDecSample->DEFAULT_HEIGHT = 1080;
134 vDecSample->DEFAULT_FRAME_RATE = 30;
135 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
136 vDecSample->WaitForEOS();
137 }
138 }
139
140 /**
141 * @tc.number : VIDEO_SWDEC_FUNCTION_0410
142 * @tc.name : test h265 asyn decode surface, pixel foramt nv21
143 * @tc.desc : function test
144 */
145 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0410, TestSize.Level0)
146 {
147 if (!access("/system/lib64/media/", 0)) {
148 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
149 vDecSample->INP_DIR = INP_DIR_1080_30;
150 vDecSample->SF_OUTPUT = true;
151 vDecSample->DEFAULT_WIDTH = 1920;
152 vDecSample->DEFAULT_HEIGHT = 1080;
153 vDecSample->DEFAULT_FRAME_RATE = 30;
154 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
155 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
156 vDecSample->WaitForEOS();
157 }
158 }
159
160 /**
161 * @tc.number : VIDEO_SWDEC_FUNCTION_0700
162 * @tc.name : test set EOS when last frame
163 * @tc.desc : function test
164 */
165 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
166 {
167 if (!access("/system/lib64/media/", 0)) {
168 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
169 vDecSample->INP_DIR = INP_DIR_1080_30;
170 vDecSample->DEFAULT_WIDTH = 1920;
171 vDecSample->DEFAULT_HEIGHT = 1080;
172 vDecSample->DEFAULT_FRAME_RATE = 30;
173 vDecSample->SF_OUTPUT = false;
174 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
175 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
176 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
177 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
178 vDecSample->WaitForEOS();
179 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
180 }
181 }
182
183 /**
184 * @tc.number : VIDEO_SWDEC_FUNCTION_0800
185 * @tc.name : test set EOS before last frame then stop
186 * @tc.desc : function test
187 */
188 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
189 {
190 if (!access("/system/lib64/media/", 0)) {
191 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
192 vDecSample->INP_DIR = INP_DIR_1080_30;
193 vDecSample->DEFAULT_WIDTH = 1920;
194 vDecSample->DEFAULT_HEIGHT = 1080;
195 vDecSample->DEFAULT_FRAME_RATE = 30;
196 vDecSample->SF_OUTPUT = false;
197 vDecSample->BEFORE_EOS_INPUT = true;
198 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
199 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
200 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
201 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
202 vDecSample->WaitForEOS();
203 }
204 }
205
206 /**
207 * @tc.number : VIDEO_SWDEC_FUNCTION_0900
208 * @tc.name : test set EOS before last frame then input frames
209 * @tc.desc : function test
210 */
211 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_0900, TestSize.Level1)
212 {
213 if (!access("/system/lib64/media/", 0)) {
214 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
215 vDecSample->INP_DIR = INP_DIR_1080_30;
216 vDecSample->DEFAULT_WIDTH = 1920;
217 vDecSample->DEFAULT_HEIGHT = 1080;
218 vDecSample->DEFAULT_FRAME_RATE = 30;
219 vDecSample->SF_OUTPUT = false;
220 vDecSample->BEFORE_EOS_INPUT_INPUT = true;
221 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
222 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
223 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
224 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
225 vDecSample->WaitForEOS();
226 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
227 }
228 }
229
230 /**
231 * @tc.number : VIDEO_SWDEC_FUNCTION_1200
232 * @tc.name : repeat start and stop 5 times before EOS
233 * @tc.desc : function test
234 */
235 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
236 {
237 if (!access("/system/lib64/media/", 0)) {
238 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
239 vDecSample->INP_DIR = INP_DIR_1080_30;
240 vDecSample->DEFAULT_WIDTH = 1920;
241 vDecSample->DEFAULT_HEIGHT = 1080;
242 vDecSample->DEFAULT_FRAME_RATE = 30;
243 vDecSample->SF_OUTPUT = false;
244 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 10;
245 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
246 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
247 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
248 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
249 vDecSample->WaitForEOS();
250 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
251 }
252 }
253
254 /**
255 * @tc.number : VIDEO_SWDEC_FUNCTION_1300
256 * @tc.name : repeat start and flush 5 times before EOS
257 * @tc.desc : function test
258 */
259 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
260 {
261 if (!access("/system/lib64/media/", 0)) {
262 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
263 vDecSample->INP_DIR = INP_DIR_1080_64_var;
264 vDecSample->DEFAULT_WIDTH = 1920;
265 vDecSample->DEFAULT_HEIGHT = 1080;
266 vDecSample->DEFAULT_FRAME_RATE = 30;
267 vDecSample->SF_OUTPUT = false;
268 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
269 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
270 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
271 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
272 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
273 vDecSample->WaitForEOS();
274 }
275 }
276
277 /**
278 * @tc.number : SURF_CHANGE_FUNC_001
279 * @tc.name : surf change in normal state
280 * @tc.desc : function test
281 */
282 HWTEST_F(HevcSwdecFuncNdkTest, SURF_CHANGE_FUNC_001, TestSize.Level0)
283 {
284 if (!access("/system/lib64/media/", 0)) {
285 auto vDecSample = make_shared<VDecNdkSample>();
286 vDecSample->INP_DIR = INP_DIR_1080_30;
287 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
288 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
289 vDecSample->DEFAULT_FRAME_RATE = 30;
290 vDecSample->SF_OUTPUT = true;
291 vDecSample->autoSwitchSurface = true;
292 vDecSample->sleepOnFPS = true;
293 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
294 vDecSample->WaitForEOS();
295 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
296 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
297 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
298 }
299 }
300
301 /**
302 * @tc.number : SURF_CHANGE_FUNC_002
303 * @tc.name : surf change in flushed state
304 * @tc.desc : function test
305 */
306 HWTEST_F(HevcSwdecFuncNdkTest, SURF_CHANGE_FUNC_002, TestSize.Level0)
307 {
308 if (!access("/system/lib64/media/", 0)) {
309 auto vDecSample = make_shared<VDecNdkSample>();
310 vDecSample->INP_DIR = INP_DIR_1080_30;
311 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
312 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
313 vDecSample->DEFAULT_FRAME_RATE = 30;
314 vDecSample->SF_OUTPUT = true;
315 vDecSample->autoSwitchSurface = true;
316 vDecSample->sleepOnFPS = true;
317 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
318 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
319 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
320 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
321 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
322 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
323 }
324 }
325
326 /**
327 * @tc.number : SURF_CHANGE_FUNC_003
328 * @tc.name : surf change in buffer mode
329 * @tc.desc : function test
330 */
331 HWTEST_F(HevcSwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)
332 {
333 if (!access("/system/lib64/media/", 0)) {
334 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
335 vDecSample->INP_DIR = INP_DIR_1080_30;
336 vDecSample->DEFAULT_WIDTH = 1920;
337 vDecSample->DEFAULT_HEIGHT = 1080;
338 vDecSample->DEFAULT_FRAME_RATE = 30;
339 vDecSample->SF_OUTPUT = false;
340 vDecSample->CreateSurface();
341 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
342 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
343 vDecSample->WaitForEOS();
344 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
345 }
346 }
347
348 /**
349 * @tc.number : SURF_CHANGE_FUNC_004
350 * @tc.name : repeat call setSurface fastly
351 * @tc.desc : function test
352 */
353 HWTEST_F(HevcSwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)
354 {
355 if (!access("/system/lib64/media/", 0)) {
356 auto vDecSample = make_shared<VDecNdkSample>();
357 vDecSample->INP_DIR = INP_DIR_1080_30;
358 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
359 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
360 vDecSample->DEFAULT_FRAME_RATE = 30;
361 vDecSample->SF_OUTPUT = true;
362 vDecSample->autoSwitchSurface = true;
363 vDecSample->sleepOnFPS = true;
364 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
365 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
366 vDecSample->WaitForEOS();
367 }
368 }
369
370
371 /**
372 * @tc.number : MAX_INPUT_SIZE_CHECK_001
373 * @tc.name : MaxInputSize value incorrect
374 * @tc.desc : function test
375 */
376 HWTEST_F(HevcSwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)
377 {
378 if (!access("/system/lib64/media/", 0)) {
379 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
380 vDecSample->INP_DIR = INP_DIR_1080_30;
381 vDecSample->DEFAULT_WIDTH = 1920;
382 vDecSample->DEFAULT_HEIGHT = 1080;
383 vDecSample->DEFAULT_FRAME_RATE = 30;
384 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
385 vDecSample->SF_OUTPUT = false;
386 vDecSample->maxInputSize = 1000;
387 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
388 vDecSample->WaitForEOS();
389 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
390 }
391 }
392
393 /**
394 * @tc.number : MAX_INPUT_SIZE_CHECK_002
395 * @tc.name : MaxInputSize value incorrect
396 * @tc.desc : function test
397 */
398 HWTEST_F(HevcSwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)
399 {
400 if (!access("/system/lib64/media/", 0)) {
401 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
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->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
407 vDecSample->SF_OUTPUT = false;
408 vDecSample->maxInputSize = 1000;
409 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
410 vDecSample->WaitForEOS();
411 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
412 }
413 }
414
415 /**
416 * @tc.number : SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_001
417 * @tc.name : Conversion from H.265 software decoding to hardware decoding
418 * @tc.desc : function test
419 */
420 HWTEST_F(HevcSwdecFuncNdkTest, SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_001, TestSize.Level0)
421 {
422 if (!access("/system/lib64/media/", 0)) {
423 for (int i = 0; i <= 39; i++) {
424 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
425 ASSERT_NE(nullptr, vdec_);
426 format = OH_AVFormat_Create();
427 ASSERT_NE(nullptr, format);
428 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
429 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
430 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
431 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
432 OH_AVFormat_Destroy(format);
433 OH_VideoDecoder_Stop(vdec_);
434 OH_VideoDecoder_Destroy(vdec_);
435 }
436 }
437 }
438
439 /**
440 * @tc.number : SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_002
441 * @tc.name : Conversion from H.265 software decoding to hardware decoding
442 * @tc.desc : function test
443 */
444 HWTEST_F(HevcSwdecFuncNdkTest, SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_002, TestSize.Level0)
445 {
446 if (!access("/system/lib64/media/", 0)) {
447 for (int i = 0; i <= 30; i++) {
448 if (i == 30) {
449 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
450 vDecSample->INP_DIR = INP_DIR_1080_30;
451 vDecSample->DEFAULT_WIDTH = 1920;
452 vDecSample->DEFAULT_HEIGHT = 1080;
453 vDecSample->DEFAULT_FRAME_RATE = 30;
454 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
455 vDecSample->SF_OUTPUT = false;
456 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
457 vDecSample->WaitForEOS();
458 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
459 }
460 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
461 ASSERT_NE(nullptr, vdec_);
462 format = OH_AVFormat_Create();
463 ASSERT_NE(nullptr, format);
464 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
465 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
466 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
467 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
468 OH_AVFormat_Destroy(format);
469 OH_VideoDecoder_Stop(vdec_);
470 OH_VideoDecoder_Destroy(vdec_);
471 }
472 }
473 }
474
475 /**
476 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0310
477 * @tc.name : test h265 asyn decode buffer, pixel foramt nv21
478 * @tc.desc : function test
479 */
480 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0310, TestSize.Level0)
481 {
482 if (!access("/system/lib64/media/", 0)) {
483 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
484 vDecSample->INP_DIR = INP_DIR_1080_30;
485 vDecSample->DEFAULT_WIDTH = 1920;
486 vDecSample->DEFAULT_HEIGHT = 1080;
487 vDecSample->DEFAULT_FRAME_RATE = 30;
488 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
489 vDecSample->SF_OUTPUT = false;
490 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
491 vDecSample->WaitForEOS();
492 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
493 }
494 }
495
496 /**
497 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0320
498 * @tc.name : test h265 decode buffer, pixel foramt nv12
499 * @tc.desc : function test
500 */
501 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0320, TestSize.Level0)
502 {
503 if (!access("/system/lib64/media/", 0)) {
504 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
505 vDecSample->INP_DIR = INP_DIR_1080_30;
506 vDecSample->DEFAULT_WIDTH = 1920;
507 vDecSample->DEFAULT_HEIGHT = 1080;
508 vDecSample->DEFAULT_FRAME_RATE = 30;
509 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
510 vDecSample->SF_OUTPUT = false;
511 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
512 vDecSample->WaitForEOS();
513 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
514 }
515 }
516
517 /**
518 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0400
519 * @tc.name : test h265 asyn decode surface, pixel foramt nv12
520 * @tc.desc : function test
521 */
522 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
523 {
524 if (!access("/system/lib64/media/", 0)) {
525 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
526 vDecSample->INP_DIR = INP_DIR_1080_30;
527 vDecSample->SF_OUTPUT = true;
528 vDecSample->DEFAULT_WIDTH = 1920;
529 vDecSample->DEFAULT_HEIGHT = 1080;
530 vDecSample->DEFAULT_FRAME_RATE = 30;
531 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
532 vDecSample->WaitForEOS();
533 }
534 }
535
536 /**
537 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0410
538 * @tc.name : test h265 decode surface, pixel foramt nv21
539 * @tc.desc : function test
540 */
541 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0410, TestSize.Level0)
542 {
543 if (!access("/system/lib64/media/", 0)) {
544 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
545 vDecSample->INP_DIR = INP_DIR_1080_30;
546 vDecSample->SF_OUTPUT = true;
547 vDecSample->DEFAULT_WIDTH = 1920;
548 vDecSample->DEFAULT_HEIGHT = 1080;
549 vDecSample->DEFAULT_FRAME_RATE = 30;
550 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
551 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
552 vDecSample->WaitForEOS();
553 }
554 }
555
556 /**
557 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0420
558 * @tc.name : test h265 asyn decode surface, pixel foramt nv12
559 * @tc.desc : function test
560 */
561 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0420, TestSize.Level0)
562 {
563 if (!access("/system/lib64/media/", 0)) {
564 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
565 vDecSample->INP_DIR = INP_DIR_1080_30;
566 vDecSample->SF_OUTPUT = true;
567 vDecSample->DEFAULT_WIDTH = 1920;
568 vDecSample->DEFAULT_HEIGHT = 1080;
569 vDecSample->DEFAULT_FRAME_RATE = 30;
570 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
571 vDecSample->WaitForEOS();
572 }
573 }
574
575 /**
576 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0430
577 * @tc.name : test h265 asyn decode surface, pixel foramt nv21
578 * @tc.desc : function test
579 */
580 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0430, TestSize.Level0)
581 {
582 if (!access("/system/lib64/media/", 0)) {
583 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
584 vDecSample->INP_DIR = INP_DIR_1080_30;
585 vDecSample->SF_OUTPUT = true;
586 vDecSample->DEFAULT_WIDTH = 1920;
587 vDecSample->DEFAULT_HEIGHT = 1080;
588 vDecSample->DEFAULT_FRAME_RATE = 30;
589 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
590 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
591 vDecSample->WaitForEOS();
592 }
593 }
594
595 /**
596 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0700
597 * @tc.name : test set EOS when last frame
598 * @tc.desc : function test
599 */
600 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
601 {
602 if (!access("/system/lib64/media/", 0)) {
603 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
604 vDecSample->INP_DIR = INP_DIR_1080_30;
605 vDecSample->DEFAULT_WIDTH = 1920;
606 vDecSample->DEFAULT_HEIGHT = 1080;
607 vDecSample->DEFAULT_FRAME_RATE = 30;
608 vDecSample->SF_OUTPUT = false;
609 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
610 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
611 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
612 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
613 vDecSample->WaitForEOS();
614 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
615 }
616 }
617
618 /**
619 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0800
620 * @tc.name : test set EOS before last frame then stop
621 * @tc.desc : function test
622 */
623 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
624 {
625 if (!access("/system/lib64/media/", 0)) {
626 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
627 vDecSample->INP_DIR = INP_DIR_1080_30;
628 vDecSample->DEFAULT_WIDTH = 1920;
629 vDecSample->DEFAULT_HEIGHT = 1080;
630 vDecSample->DEFAULT_FRAME_RATE = 30;
631 vDecSample->SF_OUTPUT = false;
632 vDecSample->BEFORE_EOS_INPUT = true;
633 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
634 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
635 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
636 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
637 vDecSample->WaitForEOS();
638 }
639 }
640
641 /**
642 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0900
643 * @tc.name : test set EOS before last frame then input frames
644 * @tc.desc : function test
645 */
646 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0900, TestSize.Level1)
647 {
648 if (!access("/system/lib64/media/", 0)) {
649 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
650 vDecSample->INP_DIR = INP_DIR_1080_30;
651 vDecSample->DEFAULT_WIDTH = 1920;
652 vDecSample->DEFAULT_HEIGHT = 1080;
653 vDecSample->DEFAULT_FRAME_RATE = 30;
654 vDecSample->SF_OUTPUT = false;
655 vDecSample->BEFORE_EOS_INPUT_INPUT = true;
656 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
657 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
658 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
659 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
660 vDecSample->WaitForEOS();
661 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
662 }
663 }
664
665 /**
666 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1000
667 * @tc.name : test reconfigure for new file with one decoder
668 * @tc.desc : function test
669 */
670 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
671 {
672 if (!access("/system/lib64/media/", 0)) {
673 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
674 vDecSample->INP_DIR = INP_DIR_1080_30;
675 vDecSample->DEFAULT_WIDTH = 1920;
676 vDecSample->DEFAULT_HEIGHT = 1080;
677 vDecSample->DEFAULT_FRAME_RATE = 30;
678 vDecSample->SF_OUTPUT = false;
679 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
680 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
681 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
682 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
683 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
684 vDecSample->WaitForEOS();
685 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
686 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
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(AV_ERR_OK, vDecSample->errCount);
692 }
693 }
694
695 /**
696 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1100
697 * @tc.name : test reconfigure for new file with the recreated decoder
698 * @tc.desc : function test
699 */
700 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
701 {
702 if (!access("/system/lib64/media/", 0)) {
703 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
704 vDecSample->INP_DIR = INP_DIR_1080_30;
705 vDecSample->DEFAULT_WIDTH = 1920;
706 vDecSample->DEFAULT_HEIGHT = 1080;
707 vDecSample->DEFAULT_FRAME_RATE = 30;
708 vDecSample->SF_OUTPUT = false;
709 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
710 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
711 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
712 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
713 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
714 vDecSample->WaitForEOS();
715 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
716 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
717 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
718 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
719 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
720 vDecSample->WaitForEOS();
721 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
722 }
723 }
724
725 /**
726 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1200
727 * @tc.name : repeat start and stop 100 times before EOS
728 * @tc.desc : function test
729 */
730 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
731 {
732 if (!access("/system/lib64/media/", 0)) {
733 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
734 vDecSample->INP_DIR = INP_DIR_1080_30;
735 vDecSample->DEFAULT_WIDTH = 1920;
736 vDecSample->DEFAULT_HEIGHT = 1080;
737 vDecSample->DEFAULT_FRAME_RATE = 30;
738 vDecSample->SF_OUTPUT = false;
739 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 100;
740 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
741 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
742 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
743 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
744 vDecSample->WaitForEOS();
745 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
746 }
747 }
748
749 /**
750 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1300
751 * @tc.name : repeat start and flush 5 times before EOS
752 * @tc.desc : function test
753 */
754 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
755 {
756 if (!access("/system/lib64/media/", 0)) {
757 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
758 vDecSample->INP_DIR = INP_DIR_var;
759 vDecSample->DEFAULT_WIDTH = 1920;
760 vDecSample->DEFAULT_HEIGHT = 1080;
761 vDecSample->DEFAULT_FRAME_RATE = 30;
762 vDecSample->SF_OUTPUT = false;
763 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
764 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
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 }
770 }
771
772 /**
773 * @tc.number : API11_SURF_CHANGE_FUNC_001
774 * @tc.name : surf change in normal state
775 * @tc.desc : function test
776 */
777 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_001, TestSize.Level0)
778 {
779 if (!access("/system/lib64/media/", 0)) {
780 auto vDecSample = make_shared<VDecAPI11Sample>();
781 vDecSample->INP_DIR = INP_DIR_1080_30;
782 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
783 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
784 vDecSample->DEFAULT_FRAME_RATE = 30;
785 vDecSample->SF_OUTPUT = true;
786 vDecSample->autoSwitchSurface = true;
787 vDecSample->sleepOnFPS = true;
788 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
789 vDecSample->WaitForEOS();
790 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
791 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
792 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
793 }
794 }
795
796 /**
797 * @tc.number : API11_SURF_CHANGE_FUNC_002
798 * @tc.name : surf change in flushed state
799 * @tc.desc : function test
800 */
801 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_002, TestSize.Level0)
802 {
803 if (!access("/system/lib64/media/", 0)) {
804 auto vDecSample = make_shared<VDecAPI11Sample>();
805 vDecSample->INP_DIR = INP_DIR_1080_30;
806 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
807 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
808 vDecSample->DEFAULT_FRAME_RATE = 30;
809 vDecSample->SF_OUTPUT = true;
810 vDecSample->autoSwitchSurface = true;
811 vDecSample->sleepOnFPS = true;
812 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
813 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
814 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
815 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
816 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
817 }
818 }
819
820 /**
821 * @tc.number : API11_SURF_CHANGE_FUNC_003
822 * @tc.name : surf change in buffer mode
823 * @tc.desc : function test
824 */
825 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_003, TestSize.Level0)
826 {
827 if (!access("/system/lib64/media/", 0)) {
828 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
829 vDecSample->INP_DIR = INP_DIR_1080_30;
830 vDecSample->DEFAULT_WIDTH = 1920;
831 vDecSample->DEFAULT_HEIGHT = 1080;
832 vDecSample->DEFAULT_FRAME_RATE = 30;
833 vDecSample->SF_OUTPUT = false;
834 vDecSample->autoSwitchSurface = false;
835 vDecSample->CreateSurface();
836 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
837 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
838 vDecSample->WaitForEOS();
839 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
840 }
841 }
842
843 /**
844 * @tc.number : API11_SURF_CHANGE_FUNC_004
845 * @tc.name : repeat call setSurface fastly
846 * @tc.desc : function test
847 */
848 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_004, TestSize.Level0)
849 {
850 if (!access("/system/lib64/media/", 0)) {
851 auto vDecSample = make_shared<VDecAPI11Sample>();
852 vDecSample->INP_DIR = INP_DIR_1080_30;
853 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
854 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
855 vDecSample->DEFAULT_FRAME_RATE = 30;
856 vDecSample->SF_OUTPUT = true;
857 vDecSample->autoSwitchSurface = true;
858 vDecSample->sleepOnFPS = true;
859 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
860 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
861 vDecSample->WaitForEOS();
862 }
863 }
864
865 /**
866 * @tc.number : API11_SURF_CHANGE_FUNC_005
867 * @tc.name : surf model change in flush to runing state
868 * @tc.desc : function test
869 */
870 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_005, TestSize.Level0)
871 {
872 if (!access("/system/lib64/media/", 0)) {
873 auto vDecSample = make_shared<VDecAPI11Sample>();
874 vDecSample->INP_DIR = INP_DIR_1080_30;
875 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
876 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
877 vDecSample->DEFAULT_FRAME_RATE = 30;
878 vDecSample->SF_OUTPUT = true;
879 vDecSample->autoSwitchSurface = true;
880 vDecSample->sleepOnFPS = true;
881 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
882 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
883 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
884 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
885 vDecSample->WaitForEOS();
886 }
887 }
888
889 /**
890 * @tc.number : API11_SURF_CHANGE_FUNC_006
891 * @tc.name : surf model change in decoder finish to End-of-Stream state
892 * @tc.desc : function test
893 */
894 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_006, TestSize.Level0)
895 {
896 if (!access("/system/lib64/media/", 0)) {
897 auto vDecSample = make_shared<VDecAPI11Sample>();
898 vDecSample->INP_DIR = INP_DIR_1080_30;
899 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
900 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
901 vDecSample->DEFAULT_FRAME_RATE = 30;
902 vDecSample->SF_OUTPUT = true;
903 vDecSample->autoSwitchSurface = true;
904 vDecSample->sleepOnFPS = true;
905 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
906 vDecSample->WaitForEOS();
907 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
908 }
909 }
910
911 /**
912 * @tc.number : API11_SURF_CHANGE_FUNC_007
913 * @tc.name : surf model change in decoder finish to End-of-Stream state
914 * @tc.desc : function test
915 */
916 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_007, TestSize.Level0)
917 {
918 if (!access("/system/lib64/media/", 0)) {
919 auto vDecSample = make_shared<VDecAPI11Sample>();
920 vDecSample->INP_DIR = INP_DIR_1080_30;
921 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
922 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
923 vDecSample->DEFAULT_FRAME_RATE = 30;
924 vDecSample->SF_OUTPUT = false;
925 vDecSample->autoSwitchSurface = false;
926 vDecSample->CreateSurface();
927 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
928 vDecSample->WaitForEOS();
929 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
930 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
931 }
932 }
933
934 /**
935 * @tc.number : API11_SURF_CHANGE_FUNC_008
936 * @tc.name : buffer model change in runing to flushed state
937 * @tc.desc : function test
938 */
939 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_008, TestSize.Level0)
940 {
941 if (!access("/system/lib64/media/", 0)) {
942 auto vDecSample = make_shared<VDecAPI11Sample>();
943 vDecSample->INP_DIR = INP_DIR_1080_30;
944 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
945 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
946 vDecSample->DEFAULT_FRAME_RATE = 30;
947 vDecSample->SF_OUTPUT = false;
948 vDecSample->autoSwitchSurface = false;
949 vDecSample->CreateSurface();
950 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
951 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
952 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
953 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
954 }
955 }
956
957 /**
958 * @tc.number : API11_SURF_CHANGE_FUNC_009
959 * @tc.name : buffer model change in flushed to runing state
960 * @tc.desc : function test
961 */
962 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_009, TestSize.Level0)
963 {
964 if (!access("/system/lib64/media/", 0)) {
965 auto vDecSample = make_shared<VDecAPI11Sample>();
966 vDecSample->INP_DIR = INP_DIR_1080_30;
967 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
968 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
969 vDecSample->DEFAULT_FRAME_RATE = 30;
970 vDecSample->SF_OUTPUT = false;
971 vDecSample->CreateSurface();
972 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
973 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
974 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
975 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
976 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
977 }
978 }
979
980 /**
981 * @tc.number : API11_SURF_CHANGE_FUNC_012
982 * @tc.name : buffer model change in normal state
983 * @tc.desc : function test
984 */
985 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_012, TestSize.Level0)
986 {
987 if (!access("/system/lib64/media/", 0)) {
988 auto vDecSample = make_shared<VDecAPI11Sample>();
989 vDecSample->INP_DIR = INP_DIR_1080_30;
990 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
991 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
992 vDecSample->DEFAULT_FRAME_RATE = 30;
993 vDecSample->SF_OUTPUT = false;
994 vDecSample->autoSwitchSurface = false;
995 vDecSample->CreateSurface();
996 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
997 vDecSample->WaitForEOS();
998 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
999 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
1000 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
1001 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1002 }
1003 }
1004
1005 /**
1006 * @tc.number : API11_SURF_CHANGE_FUNC_013
1007 * @tc.name : buffer model change in config state
1008 * @tc.desc : function test
1009 */
1010 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_013, TestSize.Level0)
1011 {
1012 if (!access("/system/lib64/media/", 0)) {
1013 auto vDecSample = make_shared<VDecAPI11Sample>();
1014 vDecSample->INP_DIR = INP_DIR_1080_30;
1015 vDecSample->DEFAULT_WIDTH = 1920;
1016 vDecSample->DEFAULT_HEIGHT = 1080;
1017 vDecSample->DEFAULT_FRAME_RATE = 30;
1018 vDecSample->SF_OUTPUT = false;
1019 vDecSample->autoSwitchSurface = false;
1020 vDecSample->CreateSurface();
1021 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1022 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1023 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1024 vDecSample->WaitForEOS();
1025 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1026 }
1027 }
1028
1029 /**
1030 * @tc.number : API11_SURF_CHANGE_FUNC_014
1031 * @tc.name : buffer model change in config state
1032 * @tc.desc : function test
1033 */
1034 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_014, TestSize.Level0)
1035 {
1036 if (!access("/system/lib64/media/", 0)) {
1037 auto vDecSample = make_shared<VDecAPI11Sample>();
1038 vDecSample->INP_DIR = INP_DIR_1080_30;
1039 vDecSample->DEFAULT_WIDTH = 1920;
1040 vDecSample->DEFAULT_HEIGHT = 1080;
1041 vDecSample->DEFAULT_FRAME_RATE = 30;
1042 vDecSample->SF_OUTPUT = false;
1043 vDecSample->autoSwitchSurface = false;
1044 vDecSample->CreateSurface();
1045 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1046 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
1047 vDecSample->WaitForEOS();
1048 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1049 }
1050 }
1051
1052 /**
1053 * @tc.number : API11_SURF_CHANGE_FUNC_016
1054 * @tc.name : Two streams repeat call setSurface fastly
1055 * @tc.desc : function test
1056 */
1057 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_016, TestSize.Level0)
1058 {
1059 if (!access("/system/lib64/media/", 0)) {
1060 auto vDecSample = make_shared<VDecAPI11Sample>();
1061 vDecSample->INP_DIR = INP_DIR_1080_30;
1062 vDecSample->DEFAULT_WIDTH = 1920;
1063 vDecSample->DEFAULT_HEIGHT = 1080;
1064 vDecSample->DEFAULT_FRAME_RATE = 30;
1065 vDecSample->SF_OUTPUT = true;
1066 vDecSample->autoSwitchSurface = true;
1067 vDecSample->sleepOnFPS = true;
1068 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
1069 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
1070 vDecSample->WaitForEOS();
1071
1072 auto vDecSample_1 = make_shared<VDecAPI11Sample>();
1073 vDecSample_1->INP_DIR = INP_DIR_1080_30;
1074 vDecSample_1->DEFAULT_WIDTH = 1920;
1075 vDecSample_1->DEFAULT_HEIGHT = 1080;
1076 vDecSample_1->DEFAULT_FRAME_RATE = 30;
1077 vDecSample_1->SF_OUTPUT = true;
1078 vDecSample_1->autoSwitchSurface = true;
1079 vDecSample_1->sleepOnFPS = true;
1080 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RunVideoDec_Surface(g_codecNameHevc));
1081 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RepeatCallSetSurface());
1082 vDecSample_1->WaitForEOS();
1083 }
1084 }
1085
1086 /**
1087 * @tc.number : API11_SURF_CHANGE_FUNC_017
1088 * @tc.name : surf change in flush to runing repeat call setSurface fastly
1089 * @tc.desc : function test
1090 */
1091 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_017, TestSize.Level0)
1092 {
1093 if (!access("/system/lib64/media/", 0)) {
1094 auto vDecSample = make_shared<VDecAPI11Sample>();
1095 vDecSample->INP_DIR = INP_DIR_1080_30;
1096 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1097 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1098 vDecSample->DEFAULT_FRAME_RATE = 30;
1099 vDecSample->SF_OUTPUT = true;
1100 vDecSample->autoSwitchSurface = true;
1101 vDecSample->sleepOnFPS = true;
1102 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
1103 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1104 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
1105 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
1106 }
1107 }
1108
1109 /**
1110 * @tc.number : API11_SURF_CHANGE_FUNC_018
1111 * @tc.name : surf change in flush to runing repeat call setSurface fastly 100
1112 * @tc.desc : function test
1113 */
1114 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_018, TestSize.Level0)
1115 {
1116 if (!access("/system/lib64/media/", 0)) {
1117 auto vDecSample = make_shared<VDecAPI11Sample>();
1118 vDecSample->INP_DIR = INP_DIR_1080_30;
1119 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1120 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1121 vDecSample->DEFAULT_FRAME_RATE = 30;
1122 vDecSample->SF_OUTPUT = true;
1123 vDecSample->autoSwitchSurface = true;
1124 vDecSample->sleepOnFPS = true;
1125 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
1126 for (int i = 0; i < 100; i++) {
1127 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1128 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
1129 }
1130 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1131 }
1132 }
1133
1134
1135 /**
1136 * @tc.number : API11_MAX_INPUT_SIZE_CHECK_001
1137 * @tc.name : MaxInputSize value incorrect
1138 * @tc.desc : function test
1139 */
1140 HWTEST_F(HevcSwdecFuncNdkTest, API11_MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)
1141 {
1142 if (!access("/system/lib64/media/", 0)) {
1143 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1144 vDecSample->INP_DIR = INP_DIR_1080_30;
1145 vDecSample->DEFAULT_WIDTH = 1920;
1146 vDecSample->DEFAULT_HEIGHT = 1080;
1147 vDecSample->DEFAULT_FRAME_RATE = 30;
1148 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
1149 vDecSample->SF_OUTPUT = false;
1150 vDecSample->maxInputSize = 1000;
1151 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1152 vDecSample->WaitForEOS();
1153 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1154 }
1155 }
1156
1157 /**
1158 * @tc.number : API11_MAX_INPUT_SIZE_CHECK_002
1159 * @tc.name : MaxInputSize value incorrect
1160 * @tc.desc : function test
1161 */
1162 HWTEST_F(HevcSwdecFuncNdkTest, API11_MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)
1163 {
1164 if (!access("/system/lib64/media/", 0)) {
1165 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1166 vDecSample->INP_DIR = INP_DIR_1080_30;
1167 vDecSample->DEFAULT_WIDTH = 1920;
1168 vDecSample->DEFAULT_HEIGHT = 1080;
1169 vDecSample->DEFAULT_FRAME_RATE = 30;
1170 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1171 vDecSample->SF_OUTPUT = false;
1172 vDecSample->maxInputSize = 1000;
1173 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1174 vDecSample->WaitForEOS();
1175 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1176 }
1177 }
1178
1179 /**
1180 * @tc.number : VIDEO_SWDEC_PARA_001
1181 * @tc.name : OH_AVFormat_SetIntValue config
1182 * @tc.desc : function test
1183 */
1184 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_001, TestSize.Level4)
1185 {
1186 if (!access("/system/lib64/media/", 0)) {
1187 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1188 ASSERT_NE(nullptr, vdec_);
1189 format = OH_AVFormat_Create();
1190 ASSERT_NE(nullptr, format);
1191 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1192 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1193 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
1194 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1195 OH_AVFormat_Destroy(format);
1196 }
1197 OH_VideoDecoder_Stop(vdec_);
1198 OH_VideoDecoder_Destroy(vdec_);
1199 }
1200
1201 /**
1202 * @tc.number : VIDEO_SWDEC_PARA_002
1203 * @tc.name : OH_AVFormat_SetIntValue config
1204 * @tc.desc : function test
1205 */
1206 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_002, TestSize.Level4)
1207 {
1208 if (!access("/system/lib64/media/", 0)) {
1209 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1210 ASSERT_NE(nullptr, vdec_);
1211 format = OH_AVFormat_Create();
1212 ASSERT_NE(nullptr, format);
1213 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1214 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1215 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
1216 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1217 OH_AVFormat_Destroy(format);
1218 }
1219 OH_VideoDecoder_Stop(vdec_);
1220 OH_VideoDecoder_Destroy(vdec_);
1221 }
1222
1223 /**
1224 * @tc.number : VIDEO_SWDEC_PARA_003
1225 * @tc.name : OH_AVFormat_SetIntValue config
1226 * @tc.desc : function test
1227 */
1228 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_003, TestSize.Level4)
1229 {
1230 if (!access("/system/lib64/media/", 0)) {
1231 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1232 ASSERT_NE(nullptr, vdec_);
1233 format = OH_AVFormat_Create();
1234 ASSERT_NE(nullptr, format);
1235 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1236 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1237 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_SURFACE_FORMAT);
1238 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1239 OH_AVFormat_Destroy(format);
1240 }
1241 OH_VideoDecoder_Stop(vdec_);
1242 OH_VideoDecoder_Destroy(vdec_);
1243 }
1244
1245 /**
1246 * @tc.number : VIDEO_SWDEC_PARA_004
1247 * @tc.name : OH_AVFormat_SetIntValue config
1248 * @tc.desc : function test
1249 */
1250 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_004, TestSize.Level4)
1251 {
1252 if (!access("/system/lib64/media/", 0)) {
1253 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1254 ASSERT_NE(nullptr, vdec_);
1255 format = OH_AVFormat_Create();
1256 ASSERT_NE(nullptr, format);
1257 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1258 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1259 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
1260 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1261 OH_AVFormat_Destroy(format);
1262 }
1263 OH_VideoDecoder_Stop(vdec_);
1264 OH_VideoDecoder_Destroy(vdec_);
1265 }
1266
1267 /**
1268 * @tc.number : VIDEO_SWDEC_PARA_005
1269 * @tc.name : OH_AVFormat_SetIntValue config
1270 * @tc.desc : function test
1271 */
1272 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_005, TestSize.Level4)
1273 {
1274 if (!access("/system/lib64/media/", 0)) {
1275 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1276 ASSERT_NE(nullptr, vdec_);
1277 format = OH_AVFormat_Create();
1278 ASSERT_NE(nullptr, format);
1279 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1280 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1281 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, 0);
1282 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1283 OH_AVFormat_Destroy(format);
1284 }
1285 OH_VideoDecoder_Stop(vdec_);
1286 OH_VideoDecoder_Destroy(vdec_);
1287 }
1288
1289 /**
1290 * @tc.number : VIDEO_SWDEC_PARA_006
1291 * @tc.name : OH_AVFormat_SetIntValue config
1292 * @tc.desc : function test
1293 */
1294 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_006, TestSize.Level4)
1295 {
1296 if (!access("/system/lib64/media/", 0)) {
1297 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1298 ASSERT_NE(nullptr, vdec_);
1299 format = OH_AVFormat_Create();
1300 ASSERT_NE(nullptr, format);
1301 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1302 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1303 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, -1);
1304 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1305 OH_AVFormat_Destroy(format);
1306 }
1307 OH_VideoDecoder_Stop(vdec_);
1308 OH_VideoDecoder_Destroy(vdec_);
1309 }
1310
1311 /**
1312 * @tc.number : VIDEO_SWDEC_PARA_007
1313 * @tc.name : test h265 decode buffer framerate -1
1314 * @tc.desc : function test
1315 */
1316 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_007, TestSize.Level0)
1317 {
1318 if (!access("/system/lib64/media/", 0)) {
1319 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1320 vDecSample->INP_DIR = INP_DIR_1080_30;
1321 vDecSample->DEFAULT_WIDTH = 1920;
1322 vDecSample->DEFAULT_HEIGHT = 1080;
1323 vDecSample->DEFAULT_FRAME_RATE = -1;
1324 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1325 vDecSample->SF_OUTPUT = false;
1326 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameHevc));
1327 vDecSample->WaitForEOS();
1328 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1329 }
1330 }
1331
1332 /**
1333 * @tc.number : VIDEO_SWDEC_PARA_008
1334 * @tc.name : test h265 decode buffer framerate 0
1335 * @tc.desc : function test
1336 */
1337 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_008, TestSize.Level0)
1338 {
1339 if (!access("/system/lib64/media/", 0)) {
1340 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1341 vDecSample->INP_DIR = INP_DIR_1080_30;
1342 vDecSample->DEFAULT_WIDTH = 1920;
1343 vDecSample->DEFAULT_HEIGHT = 1080;
1344 vDecSample->DEFAULT_FRAME_RATE = 0;
1345 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1346 vDecSample->SF_OUTPUT = false;
1347 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameHevc));
1348 vDecSample->WaitForEOS();
1349 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1350 }
1351 }
1352
1353 /**
1354 * @tc.number : VIDEO_SWDEC_PARA_008_2
1355 * @tc.name : test h265 decode buffer framerate 0.1
1356 * @tc.desc : function test
1357 */
1358 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_008_2, TestSize.Level0)
1359 {
1360 if (!access("/system/lib64/media/", 0)) {
1361 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1362 vDecSample->INP_DIR = INP_DIR_1080_30;
1363 vDecSample->DEFAULT_WIDTH = 1920;
1364 vDecSample->DEFAULT_HEIGHT = 1080;
1365 vDecSample->DEFAULT_FRAME_RATE = 0.1;
1366 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1367 vDecSample->SF_OUTPUT = false;
1368 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1369 vDecSample->WaitForEOS();
1370 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1371 }
1372 }
1373
1374 /**
1375 * @tc.number : VIDEO_SWDEC_PARA_009
1376 * @tc.name : test h265 decode buffer framerate 1
1377 * @tc.desc : function test
1378 */
1379 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_009, TestSize.Level0)
1380 {
1381 if (!access("/system/lib64/media/", 0)) {
1382 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1383 vDecSample->INP_DIR = INP_DIR_1080_30;
1384 vDecSample->DEFAULT_WIDTH = 1920;
1385 vDecSample->DEFAULT_HEIGHT = 1080;
1386 vDecSample->DEFAULT_FRAME_RATE = 1;
1387 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1388 vDecSample->SF_OUTPUT = false;
1389 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1390 vDecSample->WaitForEOS();
1391 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1392 }
1393 }
1394
1395 /**
1396 * @tc.number : VIDEO_SWDEC_PARA_010
1397 * @tc.name : test h265 decode buffer framerate 100000
1398 * @tc.desc : function test
1399 */
1400 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_010, TestSize.Level0)
1401 {
1402 if (!access("/system/lib64/media/", 0)) {
1403 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1404 vDecSample->INP_DIR = INP_DIR_1080_30;
1405 vDecSample->DEFAULT_WIDTH = 1920;
1406 vDecSample->DEFAULT_HEIGHT = 1080;
1407 vDecSample->DEFAULT_FRAME_RATE = 100000;
1408 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1409 vDecSample->SF_OUTPUT = false;
1410 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1411 vDecSample->WaitForEOS();
1412 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1413 }
1414 }
1415
1416 /**
1417 * @tc.number : VIDEO_SWDEC_PARA_011
1418 * @tc.name : width set -1 height set -1
1419 * @tc.desc : function test
1420 */
1421 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_011, TestSize.Level0)
1422 {
1423 if (!access("/system/lib64/media/", 0)) {
1424 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1425 vDecSample->INP_DIR = INP_DIR_1080_30;
1426 vDecSample->DEFAULT_WIDTH = -1;
1427 vDecSample->DEFAULT_HEIGHT = -1;
1428 vDecSample->DEFAULT_FRAME_RATE = 30;
1429 vDecSample->SF_OUTPUT = false;
1430 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1431 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1432 }
1433 }
1434
1435 /**
1436 * @tc.number : VIDEO_SWDEC_PARA_012
1437 * @tc.name : width set 0 height set 0
1438 * @tc.desc : function test
1439 */
1440 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_012, TestSize.Level0)
1441 {
1442 if (!access("/system/lib64/media/", 0)) {
1443 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1444 vDecSample->INP_DIR = INP_DIR_1080_30;
1445 vDecSample->DEFAULT_WIDTH = 0;
1446 vDecSample->DEFAULT_HEIGHT = 0;
1447 vDecSample->DEFAULT_FRAME_RATE = 30;
1448 vDecSample->SF_OUTPUT = false;
1449 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1450 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1451 }
1452 }
1453
1454 /**
1455 * @tc.number : VIDEO_SWDEC_PARA_013
1456 * @tc.name : width set 1 height set 1
1457 * @tc.desc : function test
1458 */
1459 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_013, TestSize.Level0)
1460 {
1461 if (!access("/system/lib64/media/", 0)) {
1462 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1463 vDecSample->INP_DIR = INP_DIR_1080_30;
1464 vDecSample->DEFAULT_WIDTH = 1;
1465 vDecSample->DEFAULT_HEIGHT = 1;
1466 vDecSample->DEFAULT_FRAME_RATE = 30;
1467 vDecSample->SF_OUTPUT = false;
1468 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1469 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1470 }
1471 }
1472
1473 /**
1474 * @tc.number : VIDEO_SWDEC_PARA_014
1475 * @tc.name : width set 10000 height set 10000
1476 * @tc.desc : function test
1477 */
1478 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_014, TestSize.Level0)
1479 {
1480 if (!access("/system/lib64/media/", 0)) {
1481 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1482 vDecSample->INP_DIR = INP_DIR_1080_30;
1483 vDecSample->DEFAULT_WIDTH = 10000;
1484 vDecSample->DEFAULT_HEIGHT = 10000;
1485 vDecSample->DEFAULT_FRAME_RATE = 30;
1486 vDecSample->SF_OUTPUT = false;
1487 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1488 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1489 }
1490 }
1491
1492 /**
1493 * @tc.number : VIDEO_SWDEC_PARA_015
1494 * @tc.name : width set 64 height set 64
1495 * @tc.desc : function test
1496 */
1497 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_015, TestSize.Level0)
1498 {
1499 if (!access("/system/lib64/media/", 0)) {
1500 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1501 vDecSample->INP_DIR = INP_DIR_1080_30;
1502 vDecSample->DEFAULT_WIDTH = 64;
1503 vDecSample->DEFAULT_HEIGHT = 64;
1504 vDecSample->DEFAULT_FRAME_RATE = 30;
1505 vDecSample->SF_OUTPUT = false;
1506 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1507 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1508 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1509 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1510 vDecSample->WaitForEOS();
1511 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1512 }
1513 }
1514
1515 /**
1516 * @tc.number : VIDEO_SWDEC_STABILITY_0200
1517 * @tc.name : confige start flush start reset destroy 50 times
1518 * @tc.desc : function test
1519 */
1520 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_STABILITY_FUNC_0010, TestSize.Level4)
1521 {
1522 if (!access("/system/lib64/media/", 0)) {
1523 for (int i = 0; i < g_reliCount100; i++) {
1524 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1525 ASSERT_NE(nullptr, vdec_);
1526 format = OH_AVFormat_Create();
1527 ASSERT_NE(nullptr, format);
1528 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, 1920);
1529 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
1530 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1531 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
1532 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1533 OH_AVFormat_Destroy(format);
1534 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1535 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
1536 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1537 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
1538 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
1539 }
1540 }
1541 }
1542
1543 /**
1544 * @tc.number : VIDEO_SWDEC_STABILITY_0020
1545 * @tc.name : confige start flush start reset 1000 times
1546 * @tc.desc : function test
1547 */
1548 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_STABILITY_FUNC_0020, TestSize.Level4)
1549 {
1550 if (!access("/system/lib64/media/", 0)) {
1551 for (int i = 0; i < g_reliCount100; i++) {
1552 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1553 ASSERT_NE(nullptr, vdec_);
1554 format = OH_AVFormat_Create();
1555 ASSERT_NE(nullptr, format);
1556 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, 1920);
1557 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
1558 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
1559 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
1560 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1561 OH_AVFormat_Destroy(format);
1562 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1563 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
1564 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1565 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
1566 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
1567 }
1568 }
1569 }
1570
1571 /**
1572 * @tc.number : VIDEO_SWDEC_STABILITY_FUNC_0030
1573 * @tc.name : SetParameter 50 time
1574 * @tc.desc : function test
1575 */
1576 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_STABILITY_FUNC_0030, TestSize.Level4)
1577 {
1578 if (!access("/system/lib64/media/", 0)) {
1579 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1580 ASSERT_NE(nullptr, vdec_);
1581 format = OH_AVFormat_Create();
1582 ASSERT_NE(nullptr, format);
1583 int64_t width = 1920;
1584 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, width);
1585 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
1586 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1587 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
1588 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1589 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1590 for (int i = 0; i < g_reliCount100; i++) {
1591 width--;
1592 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, width);
1593 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetParameter(vdec_, format));
1594 }
1595 OH_AVFormat_Destroy(format);
1596 OH_VideoDecoder_Stop(vdec_);
1597 OH_VideoDecoder_Destroy(vdec_);
1598 }
1599 }
1600
1601 /**
1602 * @tc.number : API11_VIDEO_SWDEC_STAB_FUNC_0100
1603 * @tc.name : 10bit stream and 8bit stream decode simultaneously
1604 * @tc.desc : function test
1605 */
1606 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STAB_FUNC_0100, TestSize.Level0)
1607 {
1608 if (!access("/system/lib64/media/", 0)) {
1609 for (int i = 0; i < g_reliCount2; i++) {
1610 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1611 vDecSample->INP_DIR = INP_DIR_144;
1612 vDecSample->SF_OUTPUT = false;
1613 vDecSample->DEFAULT_WIDTH = 176;
1614 vDecSample->DEFAULT_HEIGHT = 144;
1615 vDecSample->DEFAULT_FRAME_RATE = 30;
1616 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1617 vDecSample->WaitForEOS();
1618
1619 shared_ptr<VDecAPI11Sample> vDecSample1 = make_shared<VDecAPI11Sample>();
1620 vDecSample1->INP_DIR = INP_DIR_1080_30;
1621 vDecSample1->SF_OUTPUT = true;
1622 vDecSample1->DEFAULT_WIDTH = 1920;
1623 vDecSample1->DEFAULT_HEIGHT = 1080;
1624 vDecSample1->DEFAULT_FRAME_RATE = 30;
1625 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecNameHevc));
1626 vDecSample1->WaitForEOS();
1627 }
1628 }
1629 }
1630
1631 /**
1632 * @tc.number : API11_VIDEO_SWDEC_STABLITY_FUNC_0110
1633 * @tc.name : rand high and whith (1920 * 1080)
1634 * @tc.desc : function test
1635 */
1636 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0110, TestSize.Level0)
1637 {
1638 if (!access("/system/lib64/media/", 0)) {
1639 for (int i = 0; i < g_reliCount2; i++) {
1640 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1641 vDecSample->INP_DIR = INP_DIR_1080_30;
1642 vDecSample->DEFAULT_WIDTH = WidthRand();
1643 cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
1644 vDecSample->DEFAULT_HEIGHT = HighRand();
1645 cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
1646 vDecSample->DEFAULT_FRAME_RATE = 30;
1647 vDecSample->SF_OUTPUT = false;
1648 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1649 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1650 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1651 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1652 vDecSample->WaitForEOS();
1653 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1654 }
1655 }
1656 }
1657
1658 /**
1659 * @tc.number : API11_VIDEO_SWDEC_STABLITY_FUNC_0120
1660 * @tc.name : rand and whith (64 * 64)
1661 * @tc.desc : function test
1662 */
1663 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0120, TestSize.Level0)
1664 {
1665 if (!access("/system/lib64/media/", 0)) {
1666 for (int i = 0; i < g_reliCount2; i++) {
1667 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1668 vDecSample->INP_DIR = INP_DIR_64;
1669 vDecSample->DEFAULT_WIDTH = WidthRand();
1670 cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
1671 vDecSample->DEFAULT_HEIGHT = HighRand();
1672 cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
1673 vDecSample->DEFAULT_FRAME_RATE = 30;
1674 vDecSample->SF_OUTPUT = false;
1675 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1676 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1677 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1678 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1679 vDecSample->WaitForEOS();
1680 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1681 }
1682 }
1683 }
1684
1685 /**
1686 * @tc.number : API11_VIDEO_SWDEC_STABLITY_FUNC_0130
1687 * @tc.name : rand high and whith (176 * 144)
1688 * @tc.desc : function test
1689 */
1690 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0130, TestSize.Level0)
1691 {
1692 if (!access("/system/lib64/media/", 0)) {
1693 for (int i = 0; i < g_reliCount2; i++) {
1694 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1695 vDecSample->INP_DIR = INP_DIR_144;
1696 vDecSample->DEFAULT_WIDTH = WidthRand();
1697 cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
1698 vDecSample->DEFAULT_HEIGHT = HighRand();
1699 cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
1700 vDecSample->DEFAULT_FRAME_RATE = 30;
1701 vDecSample->SF_OUTPUT = false;
1702 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1703 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1704 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1705 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1706 vDecSample->WaitForEOS();
1707 }
1708 }
1709 }
1710
1711 /**
1712 * @tc.number : VIDEO_SWDEC_FUNCTION_001
1713 * @tc.name : test h265 decode buffer (1544 * 1158)
1714 * @tc.desc : function test
1715 */
1716 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_001, TestSize.Level3)
1717 {
1718 if (!access("/system/lib64/media/", 0)) {
1719 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1720 vDecSample->SF_OUTPUT = false;
1721 vDecSample->INP_DIR = INP_DIR_1158;
1722 vDecSample->DEFAULT_WIDTH = 1544;
1723 vDecSample->DEFAULT_HEIGHT = 1158;
1724 vDecSample->DEFAULT_FRAME_RATE = 30;
1725 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1726 vDecSample->WaitForEOS();
1727 }
1728 }
1729
1730 /**
1731 * @tc.number : VIDEO_SWDEC_FUNCTION_002
1732 * @tc.name : test h265 decode buffer (1920 * 1440)
1733 * @tc.desc : function test
1734 */
1735 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_002, TestSize.Level3)
1736 {
1737 if (!access("/system/lib64/media/", 0)) {
1738 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1739 vDecSample->INP_DIR = INP_DIR_1440;
1740 vDecSample->SF_OUTPUT = false;
1741 vDecSample->DEFAULT_WIDTH = 1920;
1742 vDecSample->DEFAULT_HEIGHT = 1440;
1743 vDecSample->DEFAULT_FRAME_RATE = 30;
1744 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1745 vDecSample->WaitForEOS();
1746 }
1747 }
1748
1749 /**
1750 * @tc.number : VIDEO_SWDEC_FUNCTION_003
1751 * @tc.name : test h265 decode buffer (1858 * 1022)
1752 * @tc.desc : function test
1753 */
1754 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_003, TestSize.Level3)
1755 {
1756 if (!access("/system/lib64/media/", 0)) {
1757 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1758 vDecSample->SF_OUTPUT = false;
1759 vDecSample->INP_DIR = INP_DIR_1022;
1760 vDecSample->DEFAULT_WIDTH = 1858;
1761 vDecSample->DEFAULT_HEIGHT = 1022;
1762 vDecSample->DEFAULT_FRAME_RATE = 30;
1763 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1764 vDecSample->WaitForEOS();
1765 }
1766 }
1767
1768 /**
1769 * @tc.number : VIDEO_SWDEC_FUNCTION_004
1770 * @tc.name : test h265 decode buffer (95 * 71)
1771 * @tc.desc : function test
1772 */
1773 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_004, TestSize.Level3)
1774 {
1775 if (!access("/system/lib64/media/", 0)) {
1776 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1777 vDecSample->SF_OUTPUT = false;
1778 vDecSample->INP_DIR = INP_DIR_71;
1779 vDecSample->DEFAULT_WIDTH = 95;
1780 vDecSample->DEFAULT_HEIGHT = 71;
1781 vDecSample->DEFAULT_FRAME_RATE = 30;
1782 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1783 vDecSample->WaitForEOS();
1784 }
1785 }
1786 } // namespace