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