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