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