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 }
323 }
324
325 /**
326 * @tc.number : SURF_CHANGE_FUNC_003
327 * @tc.name : surf change in buffer mode
328 * @tc.desc : function test
329 */
330 HWTEST_F(HevcSwdecFuncNdkTest, SURF_CHANGE_FUNC_003, TestSize.Level0)
331 {
332 if (!access("/system/lib64/media/", 0)) {
333 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
334 vDecSample->INP_DIR = INP_DIR_1080_30;
335 vDecSample->DEFAULT_WIDTH = 1920;
336 vDecSample->DEFAULT_HEIGHT = 1080;
337 vDecSample->DEFAULT_FRAME_RATE = 30;
338 vDecSample->SF_OUTPUT = false;
339 vDecSample->CreateSurface();
340 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
341 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
342 vDecSample->WaitForEOS();
343 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
344 }
345 }
346
347 /**
348 * @tc.number : SURF_CHANGE_FUNC_004
349 * @tc.name : repeat call setSurface fastly
350 * @tc.desc : function test
351 */
352 HWTEST_F(HevcSwdecFuncNdkTest, SURF_CHANGE_FUNC_004, TestSize.Level0)
353 {
354 if (!access("/system/lib64/media/", 0)) {
355 auto vDecSample = make_shared<VDecNdkSample>();
356 vDecSample->INP_DIR = INP_DIR_1080_30;
357 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
358 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
359 vDecSample->DEFAULT_FRAME_RATE = 30;
360 vDecSample->SF_OUTPUT = true;
361 vDecSample->autoSwitchSurface = true;
362 vDecSample->sleepOnFPS = true;
363 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
364 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
365 vDecSample->WaitForEOS();
366 }
367 }
368
369
370 /**
371 * @tc.number : MAX_INPUT_SIZE_CHECK_001
372 * @tc.name : MaxInputSize value incorrect
373 * @tc.desc : function test
374 */
375 HWTEST_F(HevcSwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)
376 {
377 if (!access("/system/lib64/media/", 0)) {
378 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
379 vDecSample->INP_DIR = INP_DIR_1080_30;
380 vDecSample->DEFAULT_WIDTH = 1920;
381 vDecSample->DEFAULT_HEIGHT = 1080;
382 vDecSample->DEFAULT_FRAME_RATE = 30;
383 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
384 vDecSample->SF_OUTPUT = false;
385 vDecSample->maxInputSize = 1000;
386 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
387 vDecSample->WaitForEOS();
388 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
389 }
390 }
391
392 /**
393 * @tc.number : MAX_INPUT_SIZE_CHECK_002
394 * @tc.name : MaxInputSize value incorrect
395 * @tc.desc : function test
396 */
397 HWTEST_F(HevcSwdecFuncNdkTest, MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)
398 {
399 if (!access("/system/lib64/media/", 0)) {
400 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
401 vDecSample->INP_DIR = INP_DIR_1080_30;
402 vDecSample->DEFAULT_WIDTH = 1920;
403 vDecSample->DEFAULT_HEIGHT = 1080;
404 vDecSample->DEFAULT_FRAME_RATE = 30;
405 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
406 vDecSample->SF_OUTPUT = false;
407 vDecSample->maxInputSize = 1000;
408 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
409 vDecSample->WaitForEOS();
410 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
411 }
412 }
413
414 /**
415 * @tc.number : SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_001
416 * @tc.name : Conversion from H.265 software decoding to hardware decoding
417 * @tc.desc : function test
418 */
419 HWTEST_F(HevcSwdecFuncNdkTest, SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_001, TestSize.Level0)
420 {
421 if (!access("/system/lib64/media/", 0)) {
422 for (int i = 0; i <= 39; i++) {
423 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
424 ASSERT_NE(nullptr, vdec_);
425 format = OH_AVFormat_Create();
426 ASSERT_NE(nullptr, format);
427 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
428 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
429 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
430 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
431 OH_AVFormat_Destroy(format);
432 OH_VideoDecoder_Stop(vdec_);
433 OH_VideoDecoder_Destroy(vdec_);
434 }
435 }
436 }
437
438 /**
439 * @tc.number : SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_002
440 * @tc.name : Conversion from H.265 software decoding to hardware decoding
441 * @tc.desc : function test
442 */
443 HWTEST_F(HevcSwdecFuncNdkTest, SUB_MEDIA_VIDEO_SWDEC_H265_SWITCH_002, TestSize.Level0)
444 {
445 if (!access("/system/lib64/media/", 0)) {
446 for (int i = 0; i <= 30; i++) {
447 if (i == 30) {
448 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
449 vDecSample->INP_DIR = INP_DIR_1080_30;
450 vDecSample->DEFAULT_WIDTH = 1920;
451 vDecSample->DEFAULT_HEIGHT = 1080;
452 vDecSample->DEFAULT_FRAME_RATE = 30;
453 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
454 vDecSample->SF_OUTPUT = false;
455 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
456 vDecSample->WaitForEOS();
457 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
458 }
459 vdec_ = OH_VideoDecoder_CreateByMime(OH_AVCODEC_MIMETYPE_VIDEO_HEVC);
460 ASSERT_NE(nullptr, vdec_);
461 format = OH_AVFormat_Create();
462 ASSERT_NE(nullptr, format);
463 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
464 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
465 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
466 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
467 OH_AVFormat_Destroy(format);
468 OH_VideoDecoder_Stop(vdec_);
469 OH_VideoDecoder_Destroy(vdec_);
470 }
471 }
472 }
473
474 /**
475 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0310
476 * @tc.name : test h265 asyn decode buffer, pixel foramt nv21
477 * @tc.desc : function test
478 */
479 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0310, TestSize.Level0)
480 {
481 if (!access("/system/lib64/media/", 0)) {
482 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
483 vDecSample->INP_DIR = INP_DIR_1080_30;
484 vDecSample->DEFAULT_WIDTH = 1920;
485 vDecSample->DEFAULT_HEIGHT = 1080;
486 vDecSample->DEFAULT_FRAME_RATE = 30;
487 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
488 vDecSample->SF_OUTPUT = false;
489 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
490 vDecSample->WaitForEOS();
491 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
492 }
493 }
494
495 /**
496 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0320
497 * @tc.name : test h265 decode buffer, pixel foramt nv12
498 * @tc.desc : function test
499 */
500 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0320, TestSize.Level0)
501 {
502 if (!access("/system/lib64/media/", 0)) {
503 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
504 vDecSample->INP_DIR = INP_DIR_1080_30;
505 vDecSample->DEFAULT_WIDTH = 1920;
506 vDecSample->DEFAULT_HEIGHT = 1080;
507 vDecSample->DEFAULT_FRAME_RATE = 30;
508 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
509 vDecSample->SF_OUTPUT = false;
510 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
511 vDecSample->WaitForEOS();
512 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
513 }
514 }
515
516 /**
517 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0400
518 * @tc.name : test h265 asyn decode surface, pixel foramt nv12
519 * @tc.desc : function test
520 */
521 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0400, TestSize.Level0)
522 {
523 if (!access("/system/lib64/media/", 0)) {
524 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
525 vDecSample->INP_DIR = INP_DIR_1080_30;
526 vDecSample->SF_OUTPUT = true;
527 vDecSample->DEFAULT_WIDTH = 1920;
528 vDecSample->DEFAULT_HEIGHT = 1080;
529 vDecSample->DEFAULT_FRAME_RATE = 30;
530 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
531 vDecSample->WaitForEOS();
532 }
533 }
534
535 /**
536 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0410
537 * @tc.name : test h265 decode surface, pixel foramt nv21
538 * @tc.desc : function test
539 */
540 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0410, TestSize.Level0)
541 {
542 if (!access("/system/lib64/media/", 0)) {
543 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
544 vDecSample->INP_DIR = INP_DIR_1080_30;
545 vDecSample->SF_OUTPUT = true;
546 vDecSample->DEFAULT_WIDTH = 1920;
547 vDecSample->DEFAULT_HEIGHT = 1080;
548 vDecSample->DEFAULT_FRAME_RATE = 30;
549 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
550 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
551 vDecSample->WaitForEOS();
552 }
553 }
554
555 /**
556 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0420
557 * @tc.name : test h265 asyn decode surface, pixel foramt nv12
558 * @tc.desc : function test
559 */
560 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0420, TestSize.Level0)
561 {
562 if (!access("/system/lib64/media/", 0)) {
563 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
564 vDecSample->INP_DIR = INP_DIR_1080_30;
565 vDecSample->SF_OUTPUT = true;
566 vDecSample->DEFAULT_WIDTH = 1920;
567 vDecSample->DEFAULT_HEIGHT = 1080;
568 vDecSample->DEFAULT_FRAME_RATE = 30;
569 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
570 vDecSample->WaitForEOS();
571 }
572 }
573
574 /**
575 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0430
576 * @tc.name : test h265 asyn decode surface, pixel foramt nv21
577 * @tc.desc : function test
578 */
579 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0430, TestSize.Level0)
580 {
581 if (!access("/system/lib64/media/", 0)) {
582 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
583 vDecSample->INP_DIR = INP_DIR_1080_30;
584 vDecSample->SF_OUTPUT = true;
585 vDecSample->DEFAULT_WIDTH = 1920;
586 vDecSample->DEFAULT_HEIGHT = 1080;
587 vDecSample->DEFAULT_FRAME_RATE = 30;
588 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
589 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
590 vDecSample->WaitForEOS();
591 }
592 }
593
594 /**
595 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0700
596 * @tc.name : test set EOS when last frame
597 * @tc.desc : function test
598 */
599 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0700, TestSize.Level1)
600 {
601 if (!access("/system/lib64/media/", 0)) {
602 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
603 vDecSample->INP_DIR = INP_DIR_1080_30;
604 vDecSample->DEFAULT_WIDTH = 1920;
605 vDecSample->DEFAULT_HEIGHT = 1080;
606 vDecSample->DEFAULT_FRAME_RATE = 30;
607 vDecSample->SF_OUTPUT = false;
608 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
609 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
610 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
611 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
612 vDecSample->WaitForEOS();
613 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
614 }
615 }
616
617 /**
618 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0800
619 * @tc.name : test set EOS before last frame then stop
620 * @tc.desc : function test
621 */
622 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0800, TestSize.Level1)
623 {
624 if (!access("/system/lib64/media/", 0)) {
625 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
626 vDecSample->INP_DIR = INP_DIR_1080_30;
627 vDecSample->DEFAULT_WIDTH = 1920;
628 vDecSample->DEFAULT_HEIGHT = 1080;
629 vDecSample->DEFAULT_FRAME_RATE = 30;
630 vDecSample->SF_OUTPUT = false;
631 vDecSample->BEFORE_EOS_INPUT = true;
632 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
633 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
634 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
635 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
636 vDecSample->WaitForEOS();
637 }
638 }
639
640 /**
641 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_0900
642 * @tc.name : test set EOS before last frame then input frames
643 * @tc.desc : function test
644 */
645 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_0900, TestSize.Level1)
646 {
647 if (!access("/system/lib64/media/", 0)) {
648 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
649 vDecSample->INP_DIR = INP_DIR_1080_30;
650 vDecSample->DEFAULT_WIDTH = 1920;
651 vDecSample->DEFAULT_HEIGHT = 1080;
652 vDecSample->DEFAULT_FRAME_RATE = 30;
653 vDecSample->SF_OUTPUT = false;
654 vDecSample->BEFORE_EOS_INPUT_INPUT = true;
655 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
656 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
657 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
658 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
659 vDecSample->WaitForEOS();
660 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
661 }
662 }
663
664 /**
665 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1000
666 * @tc.name : test reconfigure for new file with one decoder
667 * @tc.desc : function test
668 */
669 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1000, TestSize.Level1)
670 {
671 if (!access("/system/lib64/media/", 0)) {
672 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
673 vDecSample->INP_DIR = INP_DIR_1080_30;
674 vDecSample->DEFAULT_WIDTH = 1920;
675 vDecSample->DEFAULT_HEIGHT = 1080;
676 vDecSample->DEFAULT_FRAME_RATE = 30;
677 vDecSample->SF_OUTPUT = false;
678 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
679 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
680 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
681 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
682 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
683 vDecSample->WaitForEOS();
684 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
685 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
686 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
687 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
688 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
689 vDecSample->WaitForEOS();
690 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
691 }
692 }
693
694 /**
695 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1100
696 * @tc.name : test reconfigure for new file with the recreated decoder
697 * @tc.desc : function test
698 */
699 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1100, TestSize.Level1)
700 {
701 if (!access("/system/lib64/media/", 0)) {
702 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
703 vDecSample->INP_DIR = INP_DIR_1080_30;
704 vDecSample->DEFAULT_WIDTH = 1920;
705 vDecSample->DEFAULT_HEIGHT = 1080;
706 vDecSample->DEFAULT_FRAME_RATE = 30;
707 vDecSample->SF_OUTPUT = false;
708 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
709 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
710 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
711 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
712 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
713 vDecSample->WaitForEOS();
714 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
715 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
716 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
717 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
718 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
719 vDecSample->WaitForEOS();
720 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
721 }
722 }
723
724 /**
725 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1200
726 * @tc.name : repeat start and stop 100 times before EOS
727 * @tc.desc : function test
728 */
729 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1200, TestSize.Level2)
730 {
731 if (!access("/system/lib64/media/", 0)) {
732 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
733 vDecSample->INP_DIR = INP_DIR_1080_30;
734 vDecSample->DEFAULT_WIDTH = 1920;
735 vDecSample->DEFAULT_HEIGHT = 1080;
736 vDecSample->DEFAULT_FRAME_RATE = 30;
737 vDecSample->SF_OUTPUT = false;
738 vDecSample->REPEAT_START_STOP_BEFORE_EOS = 100;
739 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
740 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
741 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
742 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
743 vDecSample->WaitForEOS();
744 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
745 }
746 }
747
748 /**
749 * @tc.number : API11_VIDEO_SWDEC_FUNCTION_1300
750 * @tc.name : repeat start and flush 5 times before EOS
751 * @tc.desc : function test
752 */
753 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_FUNCTION_1300, TestSize.Level2)
754 {
755 if (!access("/system/lib64/media/", 0)) {
756 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
757 vDecSample->INP_DIR = INP_DIR_var;
758 vDecSample->DEFAULT_WIDTH = 1920;
759 vDecSample->DEFAULT_HEIGHT = 1080;
760 vDecSample->DEFAULT_FRAME_RATE = 30;
761 vDecSample->SF_OUTPUT = false;
762 vDecSample->REPEAT_START_FLUSH_BEFORE_EOS = 5;
763 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
764 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
765 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
766 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
767 vDecSample->WaitForEOS();
768 }
769 }
770
771 /**
772 * @tc.number : API11_SURF_CHANGE_FUNC_001
773 * @tc.name : surf change in normal state
774 * @tc.desc : function test
775 */
776 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_001, TestSize.Level0)
777 {
778 if (!access("/system/lib64/media/", 0)) {
779 auto vDecSample = make_shared<VDecAPI11Sample>();
780 vDecSample->INP_DIR = INP_DIR_1080_30;
781 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
782 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
783 vDecSample->DEFAULT_FRAME_RATE = 30;
784 vDecSample->SF_OUTPUT = true;
785 vDecSample->autoSwitchSurface = true;
786 vDecSample->sleepOnFPS = true;
787 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
788 vDecSample->WaitForEOS();
789 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
790 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
791 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
792 }
793 }
794
795 /**
796 * @tc.number : API11_SURF_CHANGE_FUNC_002
797 * @tc.name : surf change in flushed state
798 * @tc.desc : function test
799 */
800 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_002, TestSize.Level0)
801 {
802 if (!access("/system/lib64/media/", 0)) {
803 auto vDecSample = make_shared<VDecAPI11Sample>();
804 vDecSample->INP_DIR = INP_DIR_1080_30;
805 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
806 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
807 vDecSample->DEFAULT_FRAME_RATE = 30;
808 vDecSample->SF_OUTPUT = true;
809 vDecSample->autoSwitchSurface = true;
810 vDecSample->sleepOnFPS = true;
811 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
812 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
813 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
814 ASSERT_EQ(AV_ERR_OK, vDecSample->Stop());
815 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
816 }
817 }
818
819 /**
820 * @tc.number : API11_SURF_CHANGE_FUNC_003
821 * @tc.name : surf change in buffer mode
822 * @tc.desc : function test
823 */
824 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_003, TestSize.Level0)
825 {
826 if (!access("/system/lib64/media/", 0)) {
827 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
828 vDecSample->INP_DIR = INP_DIR_1080_30;
829 vDecSample->DEFAULT_WIDTH = 1920;
830 vDecSample->DEFAULT_HEIGHT = 1080;
831 vDecSample->DEFAULT_FRAME_RATE = 30;
832 vDecSample->SF_OUTPUT = false;
833 vDecSample->autoSwitchSurface = false;
834 vDecSample->CreateSurface();
835 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
836 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
837 vDecSample->WaitForEOS();
838 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
839 }
840 }
841
842 /**
843 * @tc.number : API11_SURF_CHANGE_FUNC_004
844 * @tc.name : repeat call setSurface fastly
845 * @tc.desc : function test
846 */
847 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_004, TestSize.Level0)
848 {
849 if (!access("/system/lib64/media/", 0)) {
850 auto vDecSample = make_shared<VDecAPI11Sample>();
851 vDecSample->INP_DIR = INP_DIR_1080_30;
852 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
853 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
854 vDecSample->DEFAULT_FRAME_RATE = 30;
855 vDecSample->SF_OUTPUT = true;
856 vDecSample->autoSwitchSurface = true;
857 vDecSample->sleepOnFPS = true;
858 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
859 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
860 vDecSample->WaitForEOS();
861 }
862 }
863
864 /**
865 * @tc.number : API11_SURF_CHANGE_FUNC_005
866 * @tc.name : surf model change in flush to runing state
867 * @tc.desc : function test
868 */
869 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_005, TestSize.Level0)
870 {
871 if (!access("/system/lib64/media/", 0)) {
872 auto vDecSample = make_shared<VDecAPI11Sample>();
873 vDecSample->INP_DIR = INP_DIR_1080_30;
874 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
875 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
876 vDecSample->DEFAULT_FRAME_RATE = 30;
877 vDecSample->SF_OUTPUT = true;
878 vDecSample->autoSwitchSurface = true;
879 vDecSample->sleepOnFPS = true;
880 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
881 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
882 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
883 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
884 vDecSample->WaitForEOS();
885 }
886 }
887
888 /**
889 * @tc.number : API11_SURF_CHANGE_FUNC_006
890 * @tc.name : surf model change in decoder finish to End-of-Stream state
891 * @tc.desc : function test
892 */
893 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_006, TestSize.Level0)
894 {
895 if (!access("/system/lib64/media/", 0)) {
896 auto vDecSample = make_shared<VDecAPI11Sample>();
897 vDecSample->INP_DIR = INP_DIR_1080_30;
898 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
899 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
900 vDecSample->DEFAULT_FRAME_RATE = 30;
901 vDecSample->SF_OUTPUT = true;
902 vDecSample->autoSwitchSurface = true;
903 vDecSample->sleepOnFPS = true;
904 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
905 vDecSample->WaitForEOS();
906 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
907 }
908 }
909
910 /**
911 * @tc.number : API11_SURF_CHANGE_FUNC_007
912 * @tc.name : surf model change in decoder finish to End-of-Stream state
913 * @tc.desc : function test
914 */
915 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_007, TestSize.Level0)
916 {
917 if (!access("/system/lib64/media/", 0)) {
918 auto vDecSample = make_shared<VDecAPI11Sample>();
919 vDecSample->INP_DIR = INP_DIR_1080_30;
920 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
921 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
922 vDecSample->DEFAULT_FRAME_RATE = 30;
923 vDecSample->SF_OUTPUT = false;
924 vDecSample->autoSwitchSurface = false;
925 vDecSample->CreateSurface();
926 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
927 vDecSample->WaitForEOS();
928 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
929 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
930 }
931 }
932
933 /**
934 * @tc.number : API11_SURF_CHANGE_FUNC_008
935 * @tc.name : buffer model change in runing to flushed state
936 * @tc.desc : function test
937 */
938 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_008, TestSize.Level0)
939 {
940 if (!access("/system/lib64/media/", 0)) {
941 auto vDecSample = make_shared<VDecAPI11Sample>();
942 vDecSample->INP_DIR = INP_DIR_1080_30;
943 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
944 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
945 vDecSample->DEFAULT_FRAME_RATE = 30;
946 vDecSample->SF_OUTPUT = false;
947 vDecSample->autoSwitchSurface = false;
948 vDecSample->CreateSurface();
949 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
950 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
951 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
952 }
953 }
954
955 /**
956 * @tc.number : API11_SURF_CHANGE_FUNC_009
957 * @tc.name : buffer model change in flushed to runing state
958 * @tc.desc : function test
959 */
960 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_009, TestSize.Level0)
961 {
962 if (!access("/system/lib64/media/", 0)) {
963 auto vDecSample = make_shared<VDecAPI11Sample>();
964 vDecSample->INP_DIR = INP_DIR_1080_30;
965 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
966 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
967 vDecSample->DEFAULT_FRAME_RATE = 30;
968 vDecSample->SF_OUTPUT = false;
969 vDecSample->CreateSurface();
970 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
971 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
972 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
973 ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->SwitchSurface());
974 }
975 }
976
977 /**
978 * @tc.number : API11_SURF_CHANGE_FUNC_012
979 * @tc.name : buffer model change in normal state
980 * @tc.desc : function test
981 */
982 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_012, TestSize.Level0)
983 {
984 if (!access("/system/lib64/media/", 0)) {
985 auto vDecSample = make_shared<VDecAPI11Sample>();
986 vDecSample->INP_DIR = INP_DIR_1080_30;
987 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
988 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
989 vDecSample->DEFAULT_FRAME_RATE = 30;
990 vDecSample->SF_OUTPUT = false;
991 vDecSample->autoSwitchSurface = false;
992 vDecSample->CreateSurface();
993 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
994 vDecSample->WaitForEOS();
995 ASSERT_EQ(AV_ERR_OK, vDecSample->Reset());
996 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
997 ASSERT_EQ(AV_ERR_OK, vDecSample->Release());
998 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
999 }
1000 }
1001
1002 /**
1003 * @tc.number : API11_SURF_CHANGE_FUNC_013
1004 * @tc.name : buffer model change in config state
1005 * @tc.desc : function test
1006 */
1007 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_013, TestSize.Level0)
1008 {
1009 if (!access("/system/lib64/media/", 0)) {
1010 auto vDecSample = make_shared<VDecAPI11Sample>();
1011 vDecSample->INP_DIR = INP_DIR_1080_30;
1012 vDecSample->DEFAULT_WIDTH = 1920;
1013 vDecSample->DEFAULT_HEIGHT = 1080;
1014 vDecSample->DEFAULT_FRAME_RATE = 30;
1015 vDecSample->SF_OUTPUT = false;
1016 vDecSample->autoSwitchSurface = false;
1017 vDecSample->CreateSurface();
1018 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1019 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1020 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1021 vDecSample->WaitForEOS();
1022 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1023 }
1024 }
1025
1026 /**
1027 * @tc.number : API11_SURF_CHANGE_FUNC_014
1028 * @tc.name : buffer model change in config state
1029 * @tc.desc : function test
1030 */
1031 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_014, TestSize.Level0)
1032 {
1033 if (!access("/system/lib64/media/", 0)) {
1034 auto vDecSample = make_shared<VDecAPI11Sample>();
1035 vDecSample->INP_DIR = INP_DIR_1080_30;
1036 vDecSample->DEFAULT_WIDTH = 1920;
1037 vDecSample->DEFAULT_HEIGHT = 1080;
1038 vDecSample->DEFAULT_FRAME_RATE = 30;
1039 vDecSample->SF_OUTPUT = false;
1040 vDecSample->autoSwitchSurface = false;
1041 vDecSample->CreateSurface();
1042 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1043 ASSERT_EQ(AV_ERR_INVALID_STATE, vDecSample->SwitchSurface());
1044 vDecSample->WaitForEOS();
1045 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1046 }
1047 }
1048
1049 /**
1050 * @tc.number : API11_SURF_CHANGE_FUNC_016
1051 * @tc.name : Two streams repeat call setSurface fastly
1052 * @tc.desc : function test
1053 */
1054 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_016, TestSize.Level0)
1055 {
1056 if (!access("/system/lib64/media/", 0)) {
1057 auto vDecSample = make_shared<VDecAPI11Sample>();
1058 vDecSample->INP_DIR = INP_DIR_1080_30;
1059 vDecSample->DEFAULT_WIDTH = 1920;
1060 vDecSample->DEFAULT_HEIGHT = 1080;
1061 vDecSample->DEFAULT_FRAME_RATE = 30;
1062 vDecSample->SF_OUTPUT = true;
1063 vDecSample->autoSwitchSurface = true;
1064 vDecSample->sleepOnFPS = true;
1065 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
1066 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
1067 vDecSample->WaitForEOS();
1068
1069 auto vDecSample_1 = make_shared<VDecAPI11Sample>();
1070 vDecSample_1->INP_DIR = INP_DIR_1080_30;
1071 vDecSample_1->DEFAULT_WIDTH = 1920;
1072 vDecSample_1->DEFAULT_HEIGHT = 1080;
1073 vDecSample_1->DEFAULT_FRAME_RATE = 30;
1074 vDecSample_1->SF_OUTPUT = true;
1075 vDecSample_1->autoSwitchSurface = true;
1076 vDecSample_1->sleepOnFPS = true;
1077 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RunVideoDec_Surface(g_codecNameHevc));
1078 ASSERT_EQ(AV_ERR_OK, vDecSample_1->RepeatCallSetSurface());
1079 vDecSample_1->WaitForEOS();
1080 }
1081 }
1082
1083 /**
1084 * @tc.number : API11_SURF_CHANGE_FUNC_017
1085 * @tc.name : surf change in flush to runing repeat call setSurface fastly
1086 * @tc.desc : function test
1087 */
1088 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_017, TestSize.Level0)
1089 {
1090 if (!access("/system/lib64/media/", 0)) {
1091 auto vDecSample = make_shared<VDecAPI11Sample>();
1092 vDecSample->INP_DIR = INP_DIR_1080_30;
1093 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1094 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1095 vDecSample->DEFAULT_FRAME_RATE = 30;
1096 vDecSample->SF_OUTPUT = true;
1097 vDecSample->autoSwitchSurface = true;
1098 vDecSample->sleepOnFPS = true;
1099 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
1100 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1101 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
1102 ASSERT_EQ(AV_ERR_OK, vDecSample->RepeatCallSetSurface());
1103 }
1104 }
1105
1106 /**
1107 * @tc.number : API11_SURF_CHANGE_FUNC_018
1108 * @tc.name : surf change in flush to runing repeat call setSurface fastly 100
1109 * @tc.desc : function test
1110 */
1111 HWTEST_F(HevcSwdecFuncNdkTest, API11_SURF_CHANGE_FUNC_018, TestSize.Level0)
1112 {
1113 if (!access("/system/lib64/media/", 0)) {
1114 auto vDecSample = make_shared<VDecAPI11Sample>();
1115 vDecSample->INP_DIR = INP_DIR_1080_30;
1116 vDecSample->DEFAULT_WIDTH = DEFAULT_WIDTH;
1117 vDecSample->DEFAULT_HEIGHT = DEFAULT_HEIGHT;
1118 vDecSample->DEFAULT_FRAME_RATE = 30;
1119 vDecSample->SF_OUTPUT = true;
1120 vDecSample->autoSwitchSurface = true;
1121 vDecSample->sleepOnFPS = true;
1122 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHevc));
1123 for (int i = 0; i < 100; i++) {
1124 ASSERT_EQ(AV_ERR_OK, vDecSample->Flush());
1125 ASSERT_EQ(AV_ERR_OK, vDecSample->Start());
1126 }
1127 ASSERT_EQ(AV_ERR_OK, vDecSample->SwitchSurface());
1128 }
1129 }
1130
1131
1132 /**
1133 * @tc.number : API11_MAX_INPUT_SIZE_CHECK_001
1134 * @tc.name : MaxInputSize value incorrect
1135 * @tc.desc : function test
1136 */
1137 HWTEST_F(HevcSwdecFuncNdkTest, API11_MAX_INPUT_SIZE_CHECK_001, TestSize.Level0)
1138 {
1139 if (!access("/system/lib64/media/", 0)) {
1140 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1141 vDecSample->INP_DIR = INP_DIR_1080_30;
1142 vDecSample->DEFAULT_WIDTH = 1920;
1143 vDecSample->DEFAULT_HEIGHT = 1080;
1144 vDecSample->DEFAULT_FRAME_RATE = 30;
1145 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
1146 vDecSample->SF_OUTPUT = false;
1147 vDecSample->maxInputSize = 1000;
1148 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1149 vDecSample->WaitForEOS();
1150 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1151 }
1152 }
1153
1154 /**
1155 * @tc.number : API11_MAX_INPUT_SIZE_CHECK_002
1156 * @tc.name : MaxInputSize value incorrect
1157 * @tc.desc : function test
1158 */
1159 HWTEST_F(HevcSwdecFuncNdkTest, API11_MAX_INPUT_SIZE_CHECK_002, TestSize.Level0)
1160 {
1161 if (!access("/system/lib64/media/", 0)) {
1162 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1163 vDecSample->INP_DIR = INP_DIR_1080_30;
1164 vDecSample->DEFAULT_WIDTH = 1920;
1165 vDecSample->DEFAULT_HEIGHT = 1080;
1166 vDecSample->DEFAULT_FRAME_RATE = 30;
1167 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1168 vDecSample->SF_OUTPUT = false;
1169 vDecSample->maxInputSize = 1000;
1170 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1171 vDecSample->WaitForEOS();
1172 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1173 }
1174 }
1175
1176 /**
1177 * @tc.number : VIDEO_SWDEC_PARA_001
1178 * @tc.name : OH_AVFormat_SetIntValue config
1179 * @tc.desc : function test
1180 */
1181 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_001, TestSize.Level4)
1182 {
1183 if (!access("/system/lib64/media/", 0)) {
1184 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1185 ASSERT_NE(nullptr, vdec_);
1186 format = OH_AVFormat_Create();
1187 ASSERT_NE(nullptr, format);
1188 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1189 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1190 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_YUVI420);
1191 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1192 OH_AVFormat_Destroy(format);
1193 }
1194 OH_VideoDecoder_Stop(vdec_);
1195 OH_VideoDecoder_Destroy(vdec_);
1196 }
1197
1198 /**
1199 * @tc.number : VIDEO_SWDEC_PARA_002
1200 * @tc.name : OH_AVFormat_SetIntValue config
1201 * @tc.desc : function test
1202 */
1203 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_002, TestSize.Level4)
1204 {
1205 if (!access("/system/lib64/media/", 0)) {
1206 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1207 ASSERT_NE(nullptr, vdec_);
1208 format = OH_AVFormat_Create();
1209 ASSERT_NE(nullptr, format);
1210 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1211 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1212 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
1213 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1214 OH_AVFormat_Destroy(format);
1215 }
1216 OH_VideoDecoder_Stop(vdec_);
1217 OH_VideoDecoder_Destroy(vdec_);
1218 }
1219
1220 /**
1221 * @tc.number : VIDEO_SWDEC_PARA_003
1222 * @tc.name : OH_AVFormat_SetIntValue config
1223 * @tc.desc : function test
1224 */
1225 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_003, TestSize.Level4)
1226 {
1227 if (!access("/system/lib64/media/", 0)) {
1228 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1229 ASSERT_NE(nullptr, vdec_);
1230 format = OH_AVFormat_Create();
1231 ASSERT_NE(nullptr, format);
1232 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1233 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1234 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_SURFACE_FORMAT);
1235 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1236 OH_AVFormat_Destroy(format);
1237 }
1238 OH_VideoDecoder_Stop(vdec_);
1239 OH_VideoDecoder_Destroy(vdec_);
1240 }
1241
1242 /**
1243 * @tc.number : VIDEO_SWDEC_PARA_004
1244 * @tc.name : OH_AVFormat_SetIntValue config
1245 * @tc.desc : function test
1246 */
1247 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_004, TestSize.Level4)
1248 {
1249 if (!access("/system/lib64/media/", 0)) {
1250 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1251 ASSERT_NE(nullptr, vdec_);
1252 format = OH_AVFormat_Create();
1253 ASSERT_NE(nullptr, format);
1254 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1255 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1256 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA);
1257 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1258 OH_AVFormat_Destroy(format);
1259 }
1260 OH_VideoDecoder_Stop(vdec_);
1261 OH_VideoDecoder_Destroy(vdec_);
1262 }
1263
1264 /**
1265 * @tc.number : VIDEO_SWDEC_PARA_005
1266 * @tc.name : OH_AVFormat_SetIntValue config
1267 * @tc.desc : function test
1268 */
1269 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_005, TestSize.Level4)
1270 {
1271 if (!access("/system/lib64/media/", 0)) {
1272 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1273 ASSERT_NE(nullptr, vdec_);
1274 format = OH_AVFormat_Create();
1275 ASSERT_NE(nullptr, format);
1276 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1277 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1278 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, 0);
1279 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1280 OH_AVFormat_Destroy(format);
1281 }
1282 OH_VideoDecoder_Stop(vdec_);
1283 OH_VideoDecoder_Destroy(vdec_);
1284 }
1285
1286 /**
1287 * @tc.number : VIDEO_SWDEC_PARA_006
1288 * @tc.name : OH_AVFormat_SetIntValue config
1289 * @tc.desc : function test
1290 */
1291 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_006, TestSize.Level4)
1292 {
1293 if (!access("/system/lib64/media/", 0)) {
1294 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1295 ASSERT_NE(nullptr, vdec_);
1296 format = OH_AVFormat_Create();
1297 ASSERT_NE(nullptr, format);
1298 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH);
1299 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT);
1300 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, -1);
1301 ASSERT_EQ(AV_ERR_UNSUPPORT, OH_VideoDecoder_Configure(vdec_, format));
1302 OH_AVFormat_Destroy(format);
1303 }
1304 OH_VideoDecoder_Stop(vdec_);
1305 OH_VideoDecoder_Destroy(vdec_);
1306 }
1307
1308 /**
1309 * @tc.number : VIDEO_SWDEC_PARA_007
1310 * @tc.name : test h265 decode buffer framerate -1
1311 * @tc.desc : function test
1312 */
1313 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_007, TestSize.Level0)
1314 {
1315 if (!access("/system/lib64/media/", 0)) {
1316 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1317 vDecSample->INP_DIR = INP_DIR_1080_30;
1318 vDecSample->DEFAULT_WIDTH = 1920;
1319 vDecSample->DEFAULT_HEIGHT = 1080;
1320 vDecSample->DEFAULT_FRAME_RATE = -1;
1321 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1322 vDecSample->SF_OUTPUT = false;
1323 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameHevc));
1324 vDecSample->WaitForEOS();
1325 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1326 }
1327 }
1328
1329 /**
1330 * @tc.number : VIDEO_SWDEC_PARA_008
1331 * @tc.name : test h265 decode buffer framerate 0
1332 * @tc.desc : function test
1333 */
1334 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_008, TestSize.Level0)
1335 {
1336 if (!access("/system/lib64/media/", 0)) {
1337 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1338 vDecSample->INP_DIR = INP_DIR_1080_30;
1339 vDecSample->DEFAULT_WIDTH = 1920;
1340 vDecSample->DEFAULT_HEIGHT = 1080;
1341 vDecSample->DEFAULT_FRAME_RATE = 0;
1342 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1343 vDecSample->SF_OUTPUT = false;
1344 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->RunVideoDec(g_codecNameHevc));
1345 vDecSample->WaitForEOS();
1346 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1347 }
1348 }
1349
1350 /**
1351 * @tc.number : VIDEO_SWDEC_PARA_008_2
1352 * @tc.name : test h265 decode buffer framerate 0.1
1353 * @tc.desc : function test
1354 */
1355 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_008_2, TestSize.Level0)
1356 {
1357 if (!access("/system/lib64/media/", 0)) {
1358 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1359 vDecSample->INP_DIR = INP_DIR_1080_30;
1360 vDecSample->DEFAULT_WIDTH = 1920;
1361 vDecSample->DEFAULT_HEIGHT = 1080;
1362 vDecSample->DEFAULT_FRAME_RATE = 0.1;
1363 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1364 vDecSample->SF_OUTPUT = false;
1365 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1366 vDecSample->WaitForEOS();
1367 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1368 }
1369 }
1370
1371 /**
1372 * @tc.number : VIDEO_SWDEC_PARA_009
1373 * @tc.name : test h265 decode buffer framerate 1
1374 * @tc.desc : function test
1375 */
1376 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_009, TestSize.Level0)
1377 {
1378 if (!access("/system/lib64/media/", 0)) {
1379 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1380 vDecSample->INP_DIR = INP_DIR_1080_30;
1381 vDecSample->DEFAULT_WIDTH = 1920;
1382 vDecSample->DEFAULT_HEIGHT = 1080;
1383 vDecSample->DEFAULT_FRAME_RATE = 1;
1384 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1385 vDecSample->SF_OUTPUT = false;
1386 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1387 vDecSample->WaitForEOS();
1388 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1389 }
1390 }
1391
1392 /**
1393 * @tc.number : VIDEO_SWDEC_PARA_010
1394 * @tc.name : test h265 decode buffer framerate 100000
1395 * @tc.desc : function test
1396 */
1397 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_010, TestSize.Level0)
1398 {
1399 if (!access("/system/lib64/media/", 0)) {
1400 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1401 vDecSample->INP_DIR = INP_DIR_1080_30;
1402 vDecSample->DEFAULT_WIDTH = 1920;
1403 vDecSample->DEFAULT_HEIGHT = 1080;
1404 vDecSample->DEFAULT_FRAME_RATE = 100000;
1405 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1406 vDecSample->SF_OUTPUT = false;
1407 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1408 vDecSample->WaitForEOS();
1409 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1410 }
1411 }
1412
1413 /**
1414 * @tc.number : VIDEO_SWDEC_PARA_011
1415 * @tc.name : width set -1 height set -1
1416 * @tc.desc : function test
1417 */
1418 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_011, TestSize.Level0)
1419 {
1420 if (!access("/system/lib64/media/", 0)) {
1421 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1422 vDecSample->INP_DIR = INP_DIR_1080_30;
1423 vDecSample->DEFAULT_WIDTH = -1;
1424 vDecSample->DEFAULT_HEIGHT = -1;
1425 vDecSample->DEFAULT_FRAME_RATE = 30;
1426 vDecSample->SF_OUTPUT = false;
1427 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1428 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1429 }
1430 }
1431
1432 /**
1433 * @tc.number : VIDEO_SWDEC_PARA_012
1434 * @tc.name : width set 0 height set 0
1435 * @tc.desc : function test
1436 */
1437 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_012, TestSize.Level0)
1438 {
1439 if (!access("/system/lib64/media/", 0)) {
1440 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1441 vDecSample->INP_DIR = INP_DIR_1080_30;
1442 vDecSample->DEFAULT_WIDTH = 0;
1443 vDecSample->DEFAULT_HEIGHT = 0;
1444 vDecSample->DEFAULT_FRAME_RATE = 30;
1445 vDecSample->SF_OUTPUT = false;
1446 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1447 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1448 }
1449 }
1450
1451 /**
1452 * @tc.number : VIDEO_SWDEC_PARA_013
1453 * @tc.name : width set 1 height set 1
1454 * @tc.desc : function test
1455 */
1456 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_013, TestSize.Level0)
1457 {
1458 if (!access("/system/lib64/media/", 0)) {
1459 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1460 vDecSample->INP_DIR = INP_DIR_1080_30;
1461 vDecSample->DEFAULT_WIDTH = 1;
1462 vDecSample->DEFAULT_HEIGHT = 1;
1463 vDecSample->DEFAULT_FRAME_RATE = 30;
1464 vDecSample->SF_OUTPUT = false;
1465 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1466 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1467 }
1468 }
1469
1470 /**
1471 * @tc.number : VIDEO_SWDEC_PARA_014
1472 * @tc.name : width set 10000 height set 10000
1473 * @tc.desc : function test
1474 */
1475 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_014, TestSize.Level0)
1476 {
1477 if (!access("/system/lib64/media/", 0)) {
1478 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1479 vDecSample->INP_DIR = INP_DIR_1080_30;
1480 vDecSample->DEFAULT_WIDTH = 10000;
1481 vDecSample->DEFAULT_HEIGHT = 10000;
1482 vDecSample->DEFAULT_FRAME_RATE = 30;
1483 vDecSample->SF_OUTPUT = false;
1484 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1485 ASSERT_EQ(AV_ERR_INVALID_VAL, vDecSample->ConfigureVideoDecoder());
1486 }
1487 }
1488
1489 /**
1490 * @tc.number : VIDEO_SWDEC_PARA_015
1491 * @tc.name : width set 64 height set 64
1492 * @tc.desc : function test
1493 */
1494 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_PARA_015, TestSize.Level0)
1495 {
1496 if (!access("/system/lib64/media/", 0)) {
1497 shared_ptr<VDecNdkSample> vDecSample = make_shared<VDecNdkSample>();
1498 vDecSample->INP_DIR = INP_DIR_1080_30;
1499 vDecSample->DEFAULT_WIDTH = 64;
1500 vDecSample->DEFAULT_HEIGHT = 64;
1501 vDecSample->DEFAULT_FRAME_RATE = 30;
1502 vDecSample->SF_OUTPUT = false;
1503 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1504 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1505 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1506 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1507 vDecSample->WaitForEOS();
1508 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1509 }
1510 }
1511
1512 /**
1513 * @tc.number : VIDEO_SWDEC_STABILITY_0200
1514 * @tc.name : confige start flush start reset destroy 50 times
1515 * @tc.desc : function test
1516 */
1517 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_STABILITY_FUNC_0010, TestSize.Level4)
1518 {
1519 if (!access("/system/lib64/media/", 0)) {
1520 for (int i = 0; i < g_reliCount100; i++) {
1521 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1522 ASSERT_NE(nullptr, vdec_);
1523 format = OH_AVFormat_Create();
1524 ASSERT_NE(nullptr, format);
1525 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, 1920);
1526 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
1527 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1528 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
1529 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1530 OH_AVFormat_Destroy(format);
1531 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1532 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
1533 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1534 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
1535 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
1536 }
1537 }
1538 }
1539
1540 /**
1541 * @tc.number : VIDEO_SWDEC_STABILITY_0020
1542 * @tc.name : confige start flush start reset 1000 times
1543 * @tc.desc : function test
1544 */
1545 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_STABILITY_FUNC_0020, TestSize.Level4)
1546 {
1547 if (!access("/system/lib64/media/", 0)) {
1548 for (int i = 0; i < g_reliCount100; i++) {
1549 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1550 ASSERT_NE(nullptr, vdec_);
1551 format = OH_AVFormat_Create();
1552 ASSERT_NE(nullptr, format);
1553 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, 1920);
1554 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
1555 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV21);
1556 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
1557 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1558 OH_AVFormat_Destroy(format);
1559 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1560 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Flush(vdec_));
1561 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1562 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Reset(vdec_));
1563 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Destroy(vdec_));
1564 }
1565 }
1566 }
1567
1568 /**
1569 * @tc.number : VIDEO_SWDEC_STABILITY_FUNC_0030
1570 * @tc.name : SetParameter 50 time
1571 * @tc.desc : function test
1572 */
1573 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_STABILITY_FUNC_0030, TestSize.Level4)
1574 {
1575 if (!access("/system/lib64/media/", 0)) {
1576 vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHevc.c_str());
1577 ASSERT_NE(nullptr, vdec_);
1578 format = OH_AVFormat_Create();
1579 ASSERT_NE(nullptr, format);
1580 int64_t width = 1920;
1581 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, width);
1582 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, 1080);
1583 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_NV12);
1584 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_FRAME_RATE, 30);
1585 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
1586 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Start(vdec_));
1587 for (int i = 0; i < g_reliCount100; i++) {
1588 width--;
1589 (void)OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, width);
1590 ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_SetParameter(vdec_, format));
1591 }
1592 OH_AVFormat_Destroy(format);
1593 OH_VideoDecoder_Stop(vdec_);
1594 OH_VideoDecoder_Destroy(vdec_);
1595 }
1596 }
1597
1598 /**
1599 * @tc.number : API11_VIDEO_SWDEC_STAB_FUNC_0100
1600 * @tc.name : 10bit stream and 8bit stream decode simultaneously
1601 * @tc.desc : function test
1602 */
1603 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STAB_FUNC_0100, TestSize.Level0)
1604 {
1605 if (!access("/system/lib64/media/", 0)) {
1606 for (int i = 0; i < g_reliCount2; i++) {
1607 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1608 vDecSample->INP_DIR = INP_DIR_144;
1609 vDecSample->SF_OUTPUT = false;
1610 vDecSample->DEFAULT_WIDTH = 176;
1611 vDecSample->DEFAULT_HEIGHT = 144;
1612 vDecSample->DEFAULT_FRAME_RATE = 30;
1613 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1614 vDecSample->WaitForEOS();
1615
1616 shared_ptr<VDecAPI11Sample> vDecSample1 = make_shared<VDecAPI11Sample>();
1617 vDecSample1->INP_DIR = INP_DIR_1080_30;
1618 vDecSample1->SF_OUTPUT = true;
1619 vDecSample1->DEFAULT_WIDTH = 1920;
1620 vDecSample1->DEFAULT_HEIGHT = 1080;
1621 vDecSample1->DEFAULT_FRAME_RATE = 30;
1622 ASSERT_EQ(AV_ERR_OK, vDecSample1->RunVideoDec_Surface(g_codecNameHevc));
1623 vDecSample1->WaitForEOS();
1624 }
1625 }
1626 }
1627
1628 /**
1629 * @tc.number : API11_VIDEO_SWDEC_STABLITY_FUNC_0110
1630 * @tc.name : rand high and whith (1920 * 1080)
1631 * @tc.desc : function test
1632 */
1633 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0110, TestSize.Level0)
1634 {
1635 if (!access("/system/lib64/media/", 0)) {
1636 for (int i = 0; i < g_reliCount2; i++) {
1637 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1638 vDecSample->INP_DIR = INP_DIR_1080_30;
1639 vDecSample->DEFAULT_WIDTH = WidthRand();
1640 cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
1641 vDecSample->DEFAULT_HEIGHT = HighRand();
1642 cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
1643 vDecSample->DEFAULT_FRAME_RATE = 30;
1644 vDecSample->SF_OUTPUT = false;
1645 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1646 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1647 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1648 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1649 vDecSample->WaitForEOS();
1650 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1651 }
1652 }
1653 }
1654
1655 /**
1656 * @tc.number : API11_VIDEO_SWDEC_STABLITY_FUNC_0120
1657 * @tc.name : rand and whith (64 * 64)
1658 * @tc.desc : function test
1659 */
1660 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0120, TestSize.Level0)
1661 {
1662 if (!access("/system/lib64/media/", 0)) {
1663 for (int i = 0; i < g_reliCount2; i++) {
1664 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1665 vDecSample->INP_DIR = INP_DIR_64;
1666 vDecSample->DEFAULT_WIDTH = WidthRand();
1667 cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
1668 vDecSample->DEFAULT_HEIGHT = HighRand();
1669 cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
1670 vDecSample->DEFAULT_FRAME_RATE = 30;
1671 vDecSample->SF_OUTPUT = false;
1672 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1673 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1674 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1675 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1676 vDecSample->WaitForEOS();
1677 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1678 }
1679 }
1680 }
1681
1682 /**
1683 * @tc.number : API11_VIDEO_SWDEC_STABLITY_FUNC_0130
1684 * @tc.name : rand high and whith (176 * 144)
1685 * @tc.desc : function test
1686 */
1687 HWTEST_F(HevcSwdecFuncNdkTest, API11_VIDEO_SWDEC_STABLITY_FUNC_0130, TestSize.Level0)
1688 {
1689 if (!access("/system/lib64/media/", 0)) {
1690 for (int i = 0; i < g_reliCount2; i++) {
1691 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1692 vDecSample->INP_DIR = INP_DIR_144;
1693 vDecSample->DEFAULT_WIDTH = WidthRand();
1694 cout << "rand width is: " << vDecSample->DEFAULT_WIDTH << endl;
1695 vDecSample->DEFAULT_HEIGHT = HighRand();
1696 cout << "rand high is" << vDecSample->DEFAULT_HEIGHT << endl;
1697 vDecSample->DEFAULT_FRAME_RATE = 30;
1698 vDecSample->SF_OUTPUT = false;
1699 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1700 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1701 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1702 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1703 vDecSample->WaitForEOS();
1704 }
1705 }
1706 }
1707
1708 /**
1709 * @tc.number : VIDEO_SWDEC_FUNCTION_001
1710 * @tc.name : test h265 decode buffer (1544 * 1158)
1711 * @tc.desc : function test
1712 */
1713 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_001, TestSize.Level3)
1714 {
1715 if (!access("/system/lib64/media/", 0)) {
1716 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1717 vDecSample->SF_OUTPUT = false;
1718 vDecSample->INP_DIR = INP_DIR_1158;
1719 vDecSample->DEFAULT_WIDTH = 1544;
1720 vDecSample->DEFAULT_HEIGHT = 1158;
1721 vDecSample->DEFAULT_FRAME_RATE = 30;
1722 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1723 vDecSample->WaitForEOS();
1724 }
1725 }
1726
1727 /**
1728 * @tc.number : VIDEO_SWDEC_FUNCTION_002
1729 * @tc.name : test h265 decode buffer (1920 * 1440)
1730 * @tc.desc : function test
1731 */
1732 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_002, TestSize.Level3)
1733 {
1734 if (!access("/system/lib64/media/", 0)) {
1735 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1736 vDecSample->INP_DIR = INP_DIR_1440;
1737 vDecSample->SF_OUTPUT = false;
1738 vDecSample->DEFAULT_WIDTH = 1920;
1739 vDecSample->DEFAULT_HEIGHT = 1440;
1740 vDecSample->DEFAULT_FRAME_RATE = 30;
1741 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1742 vDecSample->WaitForEOS();
1743 }
1744 }
1745
1746 /**
1747 * @tc.number : VIDEO_SWDEC_FUNCTION_003
1748 * @tc.name : test h265 decode buffer (1858 * 1022)
1749 * @tc.desc : function test
1750 */
1751 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_003, TestSize.Level3)
1752 {
1753 if (!access("/system/lib64/media/", 0)) {
1754 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1755 vDecSample->SF_OUTPUT = false;
1756 vDecSample->INP_DIR = INP_DIR_1022;
1757 vDecSample->DEFAULT_WIDTH = 1858;
1758 vDecSample->DEFAULT_HEIGHT = 1022;
1759 vDecSample->DEFAULT_FRAME_RATE = 30;
1760 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1761 vDecSample->WaitForEOS();
1762 }
1763 }
1764
1765 /**
1766 * @tc.number : VIDEO_SWDEC_FUNCTION_004
1767 * @tc.name : test h265 decode buffer (95 * 71)
1768 * @tc.desc : function test
1769 */
1770 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_FUNCTION_004, TestSize.Level3)
1771 {
1772 if (!access("/system/lib64/media/", 0)) {
1773 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1774 vDecSample->SF_OUTPUT = false;
1775 vDecSample->INP_DIR = INP_DIR_71;
1776 vDecSample->DEFAULT_WIDTH = 95;
1777 vDecSample->DEFAULT_HEIGHT = 71;
1778 vDecSample->DEFAULT_FRAME_RATE = 30;
1779 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1780 vDecSample->WaitForEOS();
1781 }
1782 }
1783
1784 /**
1785 * @tc.number : VIDEO_SWDEC_RESOLUTION_PROFILE_0010
1786 * @tc.name : Resolution and profile change
1787 * @tc.desc : function test
1788 */
1789 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_RESOLUTION_PROFILE_0010, TestSize.Level0)
1790 {
1791 if (!access("/system/lib64/media/", 0)) {
1792 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1793 vDecSample->INP_DIR = "/data/test/media/profResoChange.h265";
1794 vDecSample->DEFAULT_WIDTH = 1280;
1795 vDecSample->DEFAULT_HEIGHT = 720;
1796 vDecSample->DEFAULT_FRAME_RATE = 30;
1797 vDecSample->SF_OUTPUT = false;
1798 vDecSample->NocaleHash = true;
1799 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1800 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1801 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1802 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1803 vDecSample->WaitForEOS();
1804 ASSERT_EQ(800, vDecSample->outFrameCount);
1805 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1806 }
1807 }
1808
1809 /**
1810 * @tc.number : VIDEO_DECODE_SYNC_SW265_FUNC_0010
1811 * @tc.name : 265同步软解输出nv12
1812 * @tc.desc : function test
1813 */
1814 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW265_FUNC_0010, TestSize.Level1)
1815 {
1816 if (cap_hevc != nullptr) {
1817 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1818 vDecSample->INP_DIR = INP_DIR_1080_30;
1819 vDecSample->DEFAULT_WIDTH = 1920;
1820 vDecSample->DEFAULT_HEIGHT = 1080;
1821 vDecSample->DEFAULT_FRAME_RATE = 30;
1822 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV12;
1823 vDecSample->enbleSyncMode = 1;
1824 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1825 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1826 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1827 vDecSample->WaitForEOS();
1828 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1829 }
1830 }
1831
1832 /**
1833 * @tc.number : VIDEO_DECODE_SYNC_SW265_FUNC_0020
1834 * @tc.name : 265同步软解输出nv21
1835 * @tc.desc : function test
1836 */
1837 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW265_FUNC_0020, TestSize.Level0)
1838 {
1839 if (cap_hevc != nullptr) {
1840 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1841 vDecSample->INP_DIR = INP_DIR_1080_30;
1842 vDecSample->DEFAULT_WIDTH = 1920;
1843 vDecSample->DEFAULT_HEIGHT = 1080;
1844 vDecSample->DEFAULT_FRAME_RATE = 30;
1845 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
1846 vDecSample->enbleSyncMode = 1;
1847 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1848 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1849 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1850 vDecSample->WaitForEOS();
1851 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1852 }
1853 }
1854
1855 /**
1856 * @tc.number : VIDEO_DECODE_SYNC_SW265_FUNC_0030
1857 * @tc.name : 265同步软解输出surface
1858 * @tc.desc : function test
1859 */
1860 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_DECODE_SYNC_SW265_FUNC_0030, TestSize.Level1)
1861 {
1862 if (cap_hevc != nullptr) {
1863 shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
1864 vDecSample->INP_DIR = INP_DIR_1080_30;
1865 vDecSample->SF_OUTPUT = true;
1866 vDecSample->DEFAULT_WIDTH = 1920;
1867 vDecSample->DEFAULT_HEIGHT = 1080;
1868 vDecSample->DEFAULT_FRAME_RATE = 30;
1869 vDecSample->defualtPixelFormat = AV_PIXEL_FORMAT_NV21;
1870 vDecSample->enbleSyncMode = 1;
1871 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1872 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1873 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1874 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1875 vDecSample->WaitForEOS();
1876 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1877 }
1878 }
1879
1880 /**
1881 * @tc.number : VIDEO_SWDEC_H265_BLANK_FRAME_0010
1882 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h265 swd
1883 * @tc.desc : function test
1884 */
1885 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_H265_BLANK_FRAME_0010, TestSize.Level2)
1886 {
1887 if (cap_hevc != nullptr) {
1888 auto vDecSample = make_shared<VDecAPI11Sample>();
1889 vDecSample->INP_DIR = INP_DIR_1080_30;
1890 vDecSample->DEFAULT_WIDTH = 1920;
1891 vDecSample->DEFAULT_HEIGHT = 1080;
1892 vDecSample->DEFAULT_FRAME_RATE = 30;
1893 vDecSample->SF_OUTPUT = false;
1894 vDecSample->enbleBlankFrame = 1;
1895 ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec(g_codecNameHevc));
1896 vDecSample->WaitForEOS();
1897 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1898 }
1899 }
1900
1901 /**
1902 * @tc.number : VIDEO_SWDEC_H265_BLANK_FRAME_0020
1903 * @tc.name : config OH_MD_KEY_VIDEO_DECODER_BLANK_FRAME_ON_SHUTDOWN, decoder h265 swd, surface
1904 * @tc.desc : function test
1905 */
1906 HWTEST_F(HevcSwdecFuncNdkTest, VIDEO_SWDEC_H265_BLANK_FRAME_0020, TestSize.Level2)
1907 {
1908 if (cap_hevc != nullptr) {
1909 auto vDecSample = make_shared<VDecAPI11Sample>();
1910 vDecSample->INP_DIR = INP_DIR_1080_30;
1911 vDecSample->DEFAULT_WIDTH = 1920;
1912 vDecSample->DEFAULT_HEIGHT = 1080;
1913 vDecSample->DEFAULT_FRAME_RATE = 30;
1914 vDecSample->SF_OUTPUT = true;
1915 vDecSample->enbleBlankFrame = 1;
1916 ASSERT_EQ(AV_ERR_OK, vDecSample->CreateVideoDecoder(g_codecNameHevc));
1917 ASSERT_EQ(AV_ERR_OK, vDecSample->SetVideoDecoderCallback());
1918 ASSERT_EQ(AV_ERR_OK, vDecSample->ConfigureVideoDecoder());
1919 ASSERT_EQ(AV_ERR_OK, vDecSample->DecodeSetSurface());
1920 ASSERT_EQ(AV_ERR_OK, vDecSample->StartVideoDecoder());
1921 vDecSample->WaitForEOS();
1922 ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
1923 }
1924 }
1925 } // namespace