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