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