1 /*
2  * Copyright (C) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <string>
16 #include "gtest/gtest.h"
17 #include "native_avcodec_videodecoder.h"
18 #include "native_averrors.h"
19 #include "videodec_api11_sample.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22 #include "native_avcapability.h"
23 #include "native_buffer.h"
24 
25 #define MAX_THREAD 16
26 
27 using namespace std;
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace testing::ext;
31 
32 namespace OHOS {
33 namespace Media {
34 class HwdecHdr2SdrStateNdkTest : public testing::Test {
35 public:
36     static void SetUpTestCase();
37     static void TearDownTestCase();
38     void SetUp() override;
39     void TearDown() override;
40     void InputFunc();
41     void OutputFunc();
42     void Release();
43     int32_t Stop();
44 };
45 } // namespace Media
46 } // namespace OHOS
47 
48 VDecAPI11Sample *vDecSample2 = NULL;
SetUpTestCase()49 void HwdecHdr2SdrStateNdkTest::SetUpTestCase() {}
TearDownTestCase()50 void HwdecHdr2SdrStateNdkTest::TearDownTestCase() {}
51 
SetUp(void)52 void HwdecHdr2SdrStateNdkTest::SetUp(void)
53 {
54     vDecSample2 = new VDecAPI11Sample();
55     vDecSample2->SF_OUTPUT = true;
56     if (!access("/system/lib64/media/", 0)) {
57         vDecSample2->TRANSFER_FLAG = true;
58     } else {
59         vDecSample2->TRANSFER_FLAG = false;
60     }
61     OH_AVCapability *cap_hevc2 = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
62     string g_codecNameHEVC2 = OH_AVCapability_GetName(cap_hevc2);
63     cout << "g_codecNameHEVC2: " << g_codecNameHEVC2 << endl;
64     int32_t ret = vDecSample2->CreateVideoDecoder(g_codecNameHEVC2);
65     ASSERT_EQ(AV_ERR_OK, ret);
66     ret = vDecSample2->SetVideoDecoderCallback();
67     ASSERT_EQ(AV_ERR_OK, ret);
68     ret = vDecSample2->ConfigureVideoDecoder();
69     ASSERT_EQ(AV_ERR_OK, ret);
70     vDecSample2->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
71 }
72 
TearDown()73 void HwdecHdr2SdrStateNdkTest::TearDown()
74 {
75     vDecSample2->Release();
76     delete vDecSample2;
77     vDecSample2 = nullptr;
78 }
79 
80 namespace {
81 /**
82  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0099
83  * @tc.name      : create-configure-start-EOS-stop-start-surface
84  * @tc.desc      : function test
85  */
86 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0099, TestSize.Level2)
87 {
88     vDecSample2->SF_OUTPUT = true;
89     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
90     int32_t ret = vDecSample2->DecodeSetSurface();
91     ASSERT_EQ(AV_ERR_OK, ret);
92     ret = vDecSample2->StartVideoDecoder();
93     ASSERT_EQ(AV_ERR_OK, ret);
94     vDecSample2->WaitForEOS();
95     ASSERT_EQ(AV_ERR_OK, ret);
96     ASSERT_EQ(0, vDecSample2->errCount);
97     ret = vDecSample2->Stop();
98     ASSERT_EQ(AV_ERR_OK, ret);
99     ret = vDecSample2->Start();
100     ASSERT_EQ(AV_ERR_OK, ret);
101 }
102 
103 /**
104  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0100
105  * @tc.name      : create-configure-start-EOS-stop-release-surface
106  * @tc.desc      : function test
107  */
108 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0100, TestSize.Level2)
109 {
110     vDecSample2->SF_OUTPUT = true;
111     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
112     int32_t ret = vDecSample2->DecodeSetSurface();
113     ASSERT_EQ(AV_ERR_OK, ret);
114     ret = vDecSample2->StartVideoDecoder();
115     ASSERT_EQ(AV_ERR_OK, ret);
116     vDecSample2->WaitForEOS();
117     ASSERT_EQ(AV_ERR_OK, ret);
118     ASSERT_EQ(0, vDecSample2->errCount);
119     ret = vDecSample2->Stop();
120     ASSERT_EQ(AV_ERR_OK, ret);
121     ret = vDecSample2->Release();
122     ASSERT_EQ(AV_ERR_OK, ret);
123 }
124 
125 /**
126  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0200
127  * @tc.name      : create-configure-start-EOS-stop-reset-surface
128  * @tc.desc      : function test
129  */
130 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0200, TestSize.Level2)
131 {
132     vDecSample2->SF_OUTPUT = true;
133     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
134     int32_t ret = vDecSample2->DecodeSetSurface();
135     ASSERT_EQ(AV_ERR_OK, ret);
136     ret = vDecSample2->StartVideoDecoder();
137     ASSERT_EQ(AV_ERR_OK, ret);
138     vDecSample2->WaitForEOS();
139     ASSERT_EQ(AV_ERR_OK, ret);
140     ASSERT_EQ(0, vDecSample2->errCount);
141     ret = vDecSample2->Stop();
142     ASSERT_EQ(AV_ERR_OK, ret);
143     ret = vDecSample2->Reset();
144     ASSERT_EQ(AV_ERR_OK, ret);
145 }
146 
147 /**
148  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0300
149  * @tc.name      : create-configure-start-EOS-flush-surface
150  * @tc.desc      : function test
151  */
152 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0300, TestSize.Level2)
153 {
154     vDecSample2->SF_OUTPUT = true;
155     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
156     int32_t ret = vDecSample2->DecodeSetSurface();
157     ASSERT_EQ(AV_ERR_OK, ret);
158     ret = vDecSample2->StartVideoDecoder();
159     ASSERT_EQ(AV_ERR_OK, ret);
160     vDecSample2->WaitForEOS();
161     ASSERT_EQ(AV_ERR_OK, ret);
162     ASSERT_EQ(0, vDecSample2->errCount);
163     ret = vDecSample2->Flush();
164     ASSERT_EQ(AV_ERR_OK, ret);
165 }
166 
167 /**
168  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0400
169  * @tc.name      : create-configure-start-EOS-flush-start-surface
170  * @tc.desc      : function test
171  */
172 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0400, TestSize.Level2)
173 {
174     vDecSample2->SF_OUTPUT = true;
175     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
176     int32_t ret = vDecSample2->DecodeSetSurface();
177     ASSERT_EQ(AV_ERR_OK, ret);
178     ret = vDecSample2->StartVideoDecoder();
179     ASSERT_EQ(AV_ERR_OK, ret);
180     vDecSample2->WaitForEOS();
181     ASSERT_EQ(AV_ERR_OK, ret);
182     ASSERT_EQ(0, vDecSample2->errCount);
183     ret = vDecSample2->Flush();
184     ASSERT_EQ(AV_ERR_OK, ret);
185     ret = vDecSample2->Start();
186     ASSERT_EQ(AV_ERR_OK, ret);
187 }
188 
189 /**
190  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0500
191  * @tc.name      : create-configure-start-EOS-flush-stop-surface
192  * @tc.desc      : function test
193  */
194 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0500, TestSize.Level2)
195 {
196     vDecSample2->SF_OUTPUT = true;
197     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
198     int32_t ret = vDecSample2->DecodeSetSurface();
199     ASSERT_EQ(AV_ERR_OK, ret);
200     ret = vDecSample2->StartVideoDecoder();
201     ASSERT_EQ(AV_ERR_OK, ret);
202     vDecSample2->WaitForEOS();
203     ASSERT_EQ(AV_ERR_OK, ret);
204     ASSERT_EQ(0, vDecSample2->errCount);
205     ret = vDecSample2->Flush();
206     ASSERT_EQ(AV_ERR_OK, ret);
207     ret = vDecSample2->Stop();
208     ASSERT_EQ(AV_ERR_OK, ret);
209 }
210 
211 /**
212  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0600
213  * @tc.name      : create-configure-start-EOS-flush-reset-surface
214  * @tc.desc      : function test
215  */
216 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0600, TestSize.Level2)
217 {
218     vDecSample2->SF_OUTPUT = true;
219     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
220     int32_t ret = vDecSample2->DecodeSetSurface();
221     ASSERT_EQ(AV_ERR_OK, ret);
222     ret = vDecSample2->StartVideoDecoder();
223     ASSERT_EQ(AV_ERR_OK, ret);
224     vDecSample2->WaitForEOS();
225     ASSERT_EQ(AV_ERR_OK, ret);
226     ASSERT_EQ(0, vDecSample2->errCount);
227     ret = vDecSample2->Flush();
228     ASSERT_EQ(AV_ERR_OK, ret);
229     ret = vDecSample2->Reset();
230     ASSERT_EQ(AV_ERR_OK, ret);
231 }
232 
233 /**
234  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0700
235  * @tc.name      : create-configure-start-EOS-flush-error-surface
236  * @tc.desc      : function test
237  */
238 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0700, TestSize.Level2)
239 {
240     vDecSample2->SF_OUTPUT = true;
241     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
242     int32_t ret = vDecSample2->DecodeSetSurface();
243     ASSERT_EQ(AV_ERR_OK, ret);
244     ret = vDecSample2->StartVideoDecoder();
245     ASSERT_EQ(AV_ERR_OK, ret);
246     vDecSample2->WaitForEOS();
247     ASSERT_EQ(AV_ERR_OK, ret);
248     ASSERT_EQ(0, vDecSample2->errCount);
249     ret = vDecSample2->Flush();
250     ASSERT_EQ(AV_ERR_OK, ret);
251     ret = vDecSample2->Release();
252     ASSERT_EQ(AV_ERR_OK, ret);
253     ret = vDecSample2->ConfigureVideoDecoder();
254     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
255 }
256 
257 /**
258  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0800
259  * @tc.name      : create-configure-start-EOS-reset-configure-surface
260  * @tc.desc      : function test
261  */
262 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0800, TestSize.Level2)
263 {
264     vDecSample2->SF_OUTPUT = true;
265     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
266     int32_t ret = vDecSample2->DecodeSetSurface();
267     ASSERT_EQ(AV_ERR_OK, ret);
268     ret = vDecSample2->StartVideoDecoder();
269     ASSERT_EQ(AV_ERR_OK, ret);
270     vDecSample2->WaitForEOS();
271     ASSERT_EQ(AV_ERR_OK, ret);
272     ASSERT_EQ(0, vDecSample2->errCount);
273     ret = vDecSample2->Reset();
274     ASSERT_EQ(AV_ERR_OK, ret);
275     ret = vDecSample2->ConfigureVideoDecoder();
276     ASSERT_EQ(AV_ERR_OK, ret);
277 }
278 
279 /**
280  * @tc.number    : HEVC_HW_HDR2SDR_STATE_0900
281  * @tc.name      : create-configure-start-EOS-reset-release-surface
282  * @tc.desc      : function test
283  */
284 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0900, TestSize.Level2)
285 {
286     vDecSample2->SF_OUTPUT = true;
287     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
288     int32_t ret = vDecSample2->DecodeSetSurface();
289     ASSERT_EQ(AV_ERR_OK, ret);
290     ret = vDecSample2->StartVideoDecoder();
291     ASSERT_EQ(AV_ERR_OK, ret);
292     vDecSample2->WaitForEOS();
293     ASSERT_EQ(AV_ERR_OK, ret);
294     ASSERT_EQ(0, vDecSample2->errCount);
295     ret = vDecSample2->Reset();
296     ASSERT_EQ(AV_ERR_OK, ret);
297     ret = vDecSample2->Release();
298     ASSERT_EQ(AV_ERR_OK, ret);
299 }
300 
301 /**
302  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1000
303  * @tc.name      : create-configure-start-EOS-reset-error-surface
304  * @tc.desc      : function test
305  */
306 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1000, TestSize.Level2)
307 {
308     vDecSample2->SF_OUTPUT = true;
309     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
310     int32_t ret = vDecSample2->DecodeSetSurface();
311     ASSERT_EQ(AV_ERR_OK, ret);
312     ret = vDecSample2->StartVideoDecoder();
313     ASSERT_EQ(AV_ERR_OK, ret);
314     vDecSample2->WaitForEOS();
315     ASSERT_EQ(AV_ERR_OK, ret);
316     ASSERT_EQ(0, vDecSample2->errCount);
317     ret = vDecSample2->Reset();
318     ASSERT_EQ(AV_ERR_OK, ret);
319     ret = vDecSample2->Start();
320     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
321     ret = vDecSample2->Stop();
322     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
323     ret = vDecSample2->Flush();
324     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
325 }
326 
327 /**
328  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1100
329  * @tc.name      : create-configure-error-surface
330  * @tc.desc      : function test
331  */
332 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1100, TestSize.Level2)
333 {
334     vDecSample2->SF_OUTPUT = true;
335     int32_t ret = vDecSample2->DecodeSetSurface();
336     ASSERT_EQ(AV_ERR_OK, ret);
337     ret = vDecSample2->Flush();
338     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
339     ret = vDecSample2->SetVideoDecoderCallback();
340     ASSERT_EQ(AV_ERR_OK, ret);
341 }
342 
343 /**
344  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1101
345  * @tc.name      : create-configure-setsurface-stop
346  * @tc.desc      : function test
347  */
348 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1101, TestSize.Level2)
349 {
350     vDecSample2->SF_OUTPUT = true;
351     int32_t ret = vDecSample2->DecodeSetSurface();
352     ASSERT_EQ(AV_ERR_OK, ret);
353     ret = vDecSample2->Stop();
354     ASSERT_EQ(AV_ERR_OK, ret);
355 }
356 
357 /**
358  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1200
359  * @tc.name      : create-configure-start-stop-start-surface
360  * @tc.desc      : function test
361  */
362 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1200, TestSize.Level2)
363 {
364     vDecSample2->SF_OUTPUT = true;
365     int32_t ret = vDecSample2->DecodeSetSurface();
366     ASSERT_EQ(AV_ERR_OK, ret);
367     ret = vDecSample2->Prepare();
368     ASSERT_EQ(AV_ERR_OK, ret);
369     ret = vDecSample2->Start();
370     ASSERT_EQ(AV_ERR_OK, ret);
371     ret = vDecSample2->Stop();
372     ASSERT_EQ(AV_ERR_OK, ret);
373     ret = vDecSample2->Start();
374     ASSERT_EQ(AV_ERR_OK, ret);
375 }
376 
377 /**
378  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1300
379  * @tc.name      : create-configure-start-stop-release-surface
380  * @tc.desc      : function test
381  */
382 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1300, TestSize.Level2)
383 {
384     vDecSample2->SF_OUTPUT = true;
385     int32_t ret = vDecSample2->DecodeSetSurface();
386     ASSERT_EQ(AV_ERR_OK, ret);
387     ret = vDecSample2->Prepare();
388     ASSERT_EQ(AV_ERR_OK, ret);
389     ret = vDecSample2->Start();
390     ASSERT_EQ(AV_ERR_OK, ret);
391     ret = vDecSample2->Stop();
392     ASSERT_EQ(AV_ERR_OK, ret);
393     ret = vDecSample2->Release();
394     ASSERT_EQ(AV_ERR_OK, ret);
395 }
396 
397 /**
398  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1400
399  * @tc.name      : create-configure-start-stop-reset-surface
400  * @tc.desc      : function test
401  */
402 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1400, TestSize.Level2)
403 {
404     vDecSample2->SF_OUTPUT = true;
405     int32_t ret = vDecSample2->DecodeSetSurface();
406     ASSERT_EQ(AV_ERR_OK, ret);
407     ret = vDecSample2->Prepare();
408     ASSERT_EQ(AV_ERR_OK, ret);
409     ret = vDecSample2->Start();
410     ASSERT_EQ(AV_ERR_OK, ret);
411     ret = vDecSample2->Stop();
412     ASSERT_EQ(AV_ERR_OK, ret);
413     ret = vDecSample2->Reset();
414     ASSERT_EQ(AV_ERR_OK, ret);
415 }
416 
417 /**
418  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1500
419  * @tc.name      : create-configure-start-stop-error-surface
420  * @tc.desc      : function test
421  */
422 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1500, TestSize.Level2)
423 {
424     vDecSample2->SF_OUTPUT = true;
425     int32_t ret = vDecSample2->DecodeSetSurface();
426     ASSERT_EQ(AV_ERR_OK, ret);
427     ret = vDecSample2->Prepare();
428     ASSERT_EQ(AV_ERR_OK, ret);
429     ret = vDecSample2->Start();
430     ASSERT_EQ(AV_ERR_OK, ret);
431     ret = vDecSample2->Stop();
432     ASSERT_EQ(AV_ERR_OK, ret);
433     ret = vDecSample2->Flush();
434     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
435     ret = vDecSample2->SetVideoDecoderCallback();
436     ASSERT_EQ(AV_ERR_OK, ret);
437 }
438 
439 /**
440  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1600
441  * @tc.name      : create-configure-start-EOS-reset-error-surface
442  * @tc.desc      : function test
443  */
444 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1600, TestSize.Level2)
445 {
446     vDecSample2->SF_OUTPUT = true;
447     int32_t ret = vDecSample2->DecodeSetSurface();
448     ASSERT_EQ(AV_ERR_OK, ret);
449     ret = vDecSample2->StartVideoDecoder();
450     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
451     vDecSample2->WaitForEOS();
452     ASSERT_EQ(AV_ERR_OK, ret);
453     ASSERT_EQ(0, vDecSample2->errCount);
454     ret = vDecSample2->Reset();
455     ASSERT_EQ(AV_ERR_OK, ret);
456     ret = vDecSample2->Start();
457     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
458     ret = vDecSample2->Stop();
459     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
460     ret = vDecSample2->Flush();
461     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
462 }
463 
464 /**
465  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1700
466  * @tc.name      : create-configure-start-flush-start-flush-surface
467  * @tc.desc      : function test
468  */
469 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1700, TestSize.Level2)
470 {
471     vDecSample2->SF_OUTPUT = true;
472     int32_t ret = vDecSample2->DecodeSetSurface();
473     ASSERT_EQ(AV_ERR_OK, ret);
474     ret = vDecSample2->Prepare();
475     ASSERT_EQ(AV_ERR_OK, ret);
476     ret = vDecSample2->Start();
477     ASSERT_EQ(AV_ERR_OK, ret);
478     ret = vDecSample2->Flush();
479     ASSERT_EQ(AV_ERR_OK, ret);
480     ret = vDecSample2->Start();
481     ASSERT_EQ(AV_ERR_OK, ret);
482     ret = vDecSample2->Flush();
483     ASSERT_EQ(AV_ERR_OK, ret);
484 }
485 
486 /**
487  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1800
488  * @tc.name      : create-configure-start-flush-start-eos-surface
489  * @tc.desc      : function test
490  */
491 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1800, TestSize.Level2)
492 {
493     vDecSample2->SF_OUTPUT = true;
494     int32_t ret = vDecSample2->DecodeSetSurface();
495     ASSERT_EQ(AV_ERR_OK, ret);
496     ret = vDecSample2->Prepare();
497     ASSERT_EQ(AV_ERR_OK, ret);
498     ret = vDecSample2->Start();
499     ASSERT_EQ(AV_ERR_OK, ret);
500     ret = vDecSample2->Flush();
501     ASSERT_EQ(AV_ERR_OK, ret);
502     ret = vDecSample2->Start();
503     ASSERT_EQ(AV_ERR_OK, ret);
504     ret = vDecSample2->state_EOS();
505     ASSERT_EQ(AV_ERR_OK, ret);
506 }
507 
508 /**
509  * @tc.number    : HEVC_HW_HDR2SDR_STATE_1900
510  * @tc.name      : create-configure-start-flush-start-stop-surface
511  * @tc.desc      : function test
512  */
513 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1900, TestSize.Level2)
514 {
515     vDecSample2->SF_OUTPUT = true;
516     int32_t ret = vDecSample2->DecodeSetSurface();
517     ASSERT_EQ(AV_ERR_OK, ret);
518     ret = vDecSample2->Prepare();
519     ASSERT_EQ(AV_ERR_OK, ret);
520     ret = vDecSample2->Start();
521     ASSERT_EQ(AV_ERR_OK, ret);
522     ret = vDecSample2->Flush();
523     ASSERT_EQ(AV_ERR_OK, ret);
524     ret = vDecSample2->Start();
525     ASSERT_EQ(AV_ERR_OK, ret);
526     ret = vDecSample2->Stop();
527     ASSERT_EQ(AV_ERR_OK, ret);
528 }
529 
530 /**
531  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2000
532  * @tc.name      : create-configure-start-flush-start-reset-surface
533  * @tc.desc      : function test
534  */
535 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2000, TestSize.Level2)
536 {
537     vDecSample2->SF_OUTPUT = true;
538     int32_t ret = vDecSample2->DecodeSetSurface();
539     ASSERT_EQ(AV_ERR_OK, ret);
540     ret = vDecSample2->Prepare();
541     ASSERT_EQ(AV_ERR_OK, ret);
542     ret = vDecSample2->Start();
543     ASSERT_EQ(AV_ERR_OK, ret);
544     ret = vDecSample2->Flush();
545     ASSERT_EQ(AV_ERR_OK, ret);
546     ret = vDecSample2->Start();
547     ASSERT_EQ(AV_ERR_OK, ret);
548     ret = vDecSample2->Reset();
549     ASSERT_EQ(AV_ERR_OK, ret);
550 }
551 
552 /**
553  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2100
554  * @tc.name      : create-configure-start-flush-start-error-surface
555  * @tc.desc      : function test
556  */
557 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2100, TestSize.Level2)
558 {
559     vDecSample2->SF_OUTPUT = true;
560     int32_t ret = vDecSample2->DecodeSetSurface();
561     ASSERT_EQ(AV_ERR_OK, ret);
562     ret = vDecSample2->Prepare();
563     ASSERT_EQ(AV_ERR_OK, ret);
564     ret = vDecSample2->Start();
565     ASSERT_EQ(AV_ERR_OK, ret);
566     ret = vDecSample2->Flush();
567     ASSERT_EQ(AV_ERR_OK, ret);
568     ret = vDecSample2->Start();
569     ASSERT_EQ(AV_ERR_OK, ret);
570     ret = vDecSample2->ConfigureVideoDecoder();
571     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
572     ret = vDecSample2->SetVideoDecoderCallback();
573     ASSERT_EQ(AV_ERR_OK, ret);
574     ret = vDecSample2->Release();
575     ASSERT_EQ(AV_ERR_OK, ret);
576 }
577 
578 /**
579  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2200
580  * @tc.name      : create-configure-start-flush-start-error-surface
581  * @tc.desc      : function test
582  */
583 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2200, TestSize.Level2)
584 {
585     vDecSample2->SF_OUTPUT = true;
586     int32_t ret = vDecSample2->DecodeSetSurface();
587     ASSERT_EQ(AV_ERR_OK, ret);
588     ret = vDecSample2->Prepare();
589     ASSERT_EQ(AV_ERR_OK, ret);
590     ret = vDecSample2->Start();
591     ASSERT_EQ(AV_ERR_OK, ret);
592     ret = vDecSample2->Flush();
593     ASSERT_EQ(AV_ERR_OK, ret);
594     ret = vDecSample2->Stop();
595     ASSERT_EQ(AV_ERR_OK, ret);
596     ret = vDecSample2->Start();
597     ASSERT_EQ(AV_ERR_OK, ret);
598     cout << "set callback" << endl;
599     ret = vDecSample2->SetVideoDecoderCallback();
600     ASSERT_EQ(AV_ERR_OK, ret);
601 }
602 
603 /**
604  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2300
605  * @tc.name      : create-configure-start-flush-stop-start-surface
606  * @tc.desc      : function test
607  */
608 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2300, TestSize.Level2)
609 {
610     vDecSample2->SF_OUTPUT = true;
611     int32_t ret = vDecSample2->DecodeSetSurface();
612     ASSERT_EQ(AV_ERR_OK, ret);
613     ret = vDecSample2->Prepare();
614     ASSERT_EQ(AV_ERR_OK, ret);
615     ret = vDecSample2->Start();
616     ASSERT_EQ(AV_ERR_OK, ret);
617     ret = vDecSample2->Flush();
618     ASSERT_EQ(AV_ERR_OK, ret);
619     ret = vDecSample2->Stop();
620     ASSERT_EQ(AV_ERR_OK, ret);
621     ret = vDecSample2->Release();
622     ASSERT_EQ(AV_ERR_OK, ret);
623 }
624 
625 /**
626  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2400
627  * @tc.name      : create-configure-start-flush-stop-reset-surface
628  * @tc.desc      : function test
629  */
630 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2400, TestSize.Level2)
631 {
632     vDecSample2->SF_OUTPUT = true;
633     int32_t ret = vDecSample2->DecodeSetSurface();
634     ASSERT_EQ(AV_ERR_OK, ret);
635     ret = vDecSample2->Prepare();
636     ASSERT_EQ(AV_ERR_OK, ret);
637     ret = vDecSample2->Start();
638     ASSERT_EQ(AV_ERR_OK, ret);
639     ret = vDecSample2->Flush();
640     ASSERT_EQ(AV_ERR_OK, ret);
641     ret = vDecSample2->Stop();
642     ASSERT_EQ(AV_ERR_OK, ret);
643     ret = vDecSample2->Reset();
644     ASSERT_EQ(AV_ERR_OK, ret);
645 }
646 
647 /**
648  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2500
649  * @tc.name      : create-configure-start-flush-stop-error-surface
650  * @tc.desc      : function test
651  */
652 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2500, TestSize.Level2)
653 {
654     vDecSample2->SF_OUTPUT = true;
655     int32_t ret = vDecSample2->DecodeSetSurface();
656     ASSERT_EQ(AV_ERR_OK, ret);
657     ret = vDecSample2->Prepare();
658     ASSERT_EQ(AV_ERR_OK, ret);
659     ret = vDecSample2->Start();
660     ASSERT_EQ(AV_ERR_OK, ret);
661     ret = vDecSample2->Flush();
662     ASSERT_EQ(AV_ERR_OK, ret);
663     ret = vDecSample2->Stop();
664     ASSERT_EQ(AV_ERR_OK, ret);
665     ret = vDecSample2->Flush();
666     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
667     ret = vDecSample2->SetVideoDecoderCallback();
668     ASSERT_EQ(AV_ERR_OK, ret);
669 }
670 
671 /**
672  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2600
673  * @tc.name      : create-configure-start-flush-reset-configure-surface
674  * @tc.desc      : function test
675  */
676 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2600, TestSize.Level2)
677 {
678     vDecSample2->SF_OUTPUT = true;
679     int32_t ret = vDecSample2->DecodeSetSurface();
680     ASSERT_EQ(AV_ERR_OK, ret);
681     ret = vDecSample2->Prepare();
682     ASSERT_EQ(AV_ERR_OK, ret);
683     ret = vDecSample2->Start();
684     ASSERT_EQ(AV_ERR_OK, ret);
685     ret = vDecSample2->Flush();
686     ASSERT_EQ(AV_ERR_OK, ret);
687     ret = vDecSample2->Reset();
688     ASSERT_EQ(AV_ERR_OK, ret);
689     ret = vDecSample2->ConfigureVideoDecoder();
690     ASSERT_EQ(AV_ERR_OK, ret);
691 }
692 
693 /**
694  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2700
695  * @tc.name      : create-configure-start-flush-reset-release-surface
696  * @tc.desc      : function test
697  */
698 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2700, TestSize.Level2)
699 {
700     vDecSample2->SF_OUTPUT = true;
701     int32_t ret = vDecSample2->DecodeSetSurface();
702     ASSERT_EQ(AV_ERR_OK, ret);
703     ret = vDecSample2->Prepare();
704     ASSERT_EQ(AV_ERR_OK, ret);
705     ret = vDecSample2->Start();
706     ASSERT_EQ(AV_ERR_OK, ret);
707     ret = vDecSample2->Flush();
708     ASSERT_EQ(AV_ERR_OK, ret);
709     ret = vDecSample2->Reset();
710     ASSERT_EQ(AV_ERR_OK, ret);
711     ret = vDecSample2->Release();
712     ASSERT_EQ(AV_ERR_OK, ret);
713 }
714 
715 /**
716  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2800
717  * @tc.name      : create-configure-start-flush-reset-error-surface
718  * @tc.desc      : function test
719  */
720 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2800, TestSize.Level2)
721 {
722     vDecSample2->SF_OUTPUT = true;
723     int32_t ret = vDecSample2->DecodeSetSurface();
724     ASSERT_EQ(AV_ERR_OK, ret);
725     ret = vDecSample2->Prepare();
726     ASSERT_EQ(AV_ERR_OK, ret);
727     ret = vDecSample2->Start();
728     ASSERT_EQ(AV_ERR_OK, ret);
729     ret = vDecSample2->Flush();
730     ASSERT_EQ(AV_ERR_OK, ret);
731     ret = vDecSample2->Reset();
732     ASSERT_EQ(AV_ERR_OK, ret);
733     ret = vDecSample2->Start();
734     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
735     ret = vDecSample2->Stop();
736     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
737     ret = vDecSample2->Flush();
738     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
739     ret = vDecSample2->SetVideoDecoderCallback();
740     ASSERT_EQ(AV_ERR_OK, ret);
741 }
742 
743 /**
744  * @tc.number    : HEVC_HW_HDR2SDR_STATE_2900
745  * @tc.name      : create-configure-start-reset-configure-surface
746  * @tc.desc      : function test
747  */
748 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2900, TestSize.Level2)
749 {
750     vDecSample2->SF_OUTPUT = true;
751     int32_t ret = vDecSample2->DecodeSetSurface();
752     ASSERT_EQ(AV_ERR_OK, ret);
753     ret = vDecSample2->Prepare();
754     ASSERT_EQ(AV_ERR_OK, ret);
755     ret = vDecSample2->Start();
756     ASSERT_EQ(AV_ERR_OK, ret);
757     ret = vDecSample2->Reset();
758     ASSERT_EQ(AV_ERR_OK, ret);
759     ret = vDecSample2->ConfigureVideoDecoder();
760     ASSERT_EQ(AV_ERR_OK, ret);
761 }
762 
763 /**
764  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3000
765  * @tc.name      : create-configure-start-reset-release-surface
766  * @tc.desc      : function test
767  */
768 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3000, TestSize.Level2)
769 {
770     vDecSample2->SF_OUTPUT = true;
771     int32_t ret = vDecSample2->DecodeSetSurface();
772     ASSERT_EQ(AV_ERR_OK, ret);
773     ret = vDecSample2->Prepare();
774     ASSERT_EQ(AV_ERR_OK, ret);
775     ret = vDecSample2->Start();
776     ASSERT_EQ(AV_ERR_OK, ret);
777     ret = vDecSample2->Reset();
778     ASSERT_EQ(AV_ERR_OK, ret);
779     ret = vDecSample2->Release();
780     ASSERT_EQ(AV_ERR_OK, ret);
781 }
782 
783 /**
784  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3100
785  * @tc.name      : create-configure-start-reset-error-surface
786  * @tc.desc      : function test
787  */
788 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3100, TestSize.Level2)
789 {
790     vDecSample2->SF_OUTPUT = true;
791     int32_t ret = vDecSample2->DecodeSetSurface();
792     ASSERT_EQ(AV_ERR_OK, ret);
793     ret = vDecSample2->Prepare();
794     ASSERT_EQ(AV_ERR_OK, ret);
795     ret = vDecSample2->Start();
796     ASSERT_EQ(AV_ERR_OK, ret);
797     ret = vDecSample2->Reset();
798     ASSERT_EQ(AV_ERR_OK, ret);
799     ret = vDecSample2->Start();
800     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
801     ret = vDecSample2->Stop();
802     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
803     ret = vDecSample2->Flush();
804     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
805     ret = vDecSample2->SetVideoDecoderCallback();
806     ASSERT_EQ(AV_ERR_OK, ret);
807 }
808 
809 /**
810  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3200
811  * @tc.name      : create-configure-start-error-surface
812  * @tc.desc      : function test
813  */
814 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3200, TestSize.Level2)
815 {
816     vDecSample2->SF_OUTPUT = true;
817     int32_t ret = vDecSample2->DecodeSetSurface();
818     ASSERT_EQ(AV_ERR_OK, ret);
819     ret = vDecSample2->Prepare();
820     ASSERT_EQ(AV_ERR_OK, ret);
821     ret = vDecSample2->Start();
822     ASSERT_EQ(AV_ERR_OK, ret);
823     ret = vDecSample2->ConfigureVideoDecoder();
824     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
825     ret = vDecSample2->SetVideoDecoderCallback();
826     ASSERT_EQ(AV_ERR_OK, ret);
827     ret = vDecSample2->Release();
828     ASSERT_EQ(AV_ERR_OK, ret);
829 }
830 
831 /**
832  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3300
833  * @tc.name      : create-configure-reset-configure-surface
834  * @tc.desc      : function test
835  */
836 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3300, TestSize.Level2)
837 {
838     vDecSample2->SF_OUTPUT = true;
839     int32_t ret = vDecSample2->DecodeSetSurface();
840     ASSERT_EQ(AV_ERR_OK, ret);
841     ret = vDecSample2->Reset();
842     ASSERT_EQ(AV_ERR_OK, ret);
843     ret = vDecSample2->ConfigureVideoDecoder();
844     ASSERT_EQ(AV_ERR_OK, ret);
845 }
846 
847 /**
848  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3400
849  * @tc.name      : create-configure-release-surface
850  * @tc.desc      : function test
851  */
852 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3400, TestSize.Level2)
853 {
854     vDecSample2->SF_OUTPUT = true;
855     int32_t ret = vDecSample2->DecodeSetSurface();
856     ASSERT_EQ(AV_ERR_OK, ret);
857     ret = vDecSample2->Release();
858     ASSERT_EQ(AV_ERR_OK, ret);
859 }
860 
861 /**
862  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3500
863  * @tc.name      : Flush or stop in buffe decoder callback function-surface
864  * @tc.desc      : function test
865  */
866 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3500, TestSize.Level1)
867 {
868     vDecSample2->SF_OUTPUT = true;
869     int32_t ret = vDecSample2->DecodeSetSurface();
870     ASSERT_EQ(AV_ERR_OK, ret);
871     vDecSample2->inputCallbackFlush = true;
872     ret = vDecSample2->StartVideoDecoder();
873     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
874     vDecSample2->WaitForEOS();
875     ASSERT_EQ(AV_ERR_OK, ret);
876 }
877 
878 /**
879  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3600
880  * @tc.name      : Flush or stop in buffe decoder callback function-surface
881  * @tc.desc      : function test
882  */
883 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3600, TestSize.Level1)
884 {
885     vDecSample2->SF_OUTPUT = true;
886     int32_t ret = vDecSample2->DecodeSetSurface();
887     ASSERT_EQ(AV_ERR_OK, ret);
888     vDecSample2->inputCallbackStop = true;
889     ret = vDecSample2->StartVideoDecoder();
890     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
891     ASSERT_EQ(AV_ERR_OK, ret);
892     vDecSample2->WaitForEOS();
893 }
894 
895 /**
896  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3700
897  * @tc.name      : Flush or stop in buffe decoder callback function-surface
898  * @tc.desc      : function test
899  */
900 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3700, TestSize.Level1)
901 {
902     vDecSample2->SF_OUTPUT = true;
903     int32_t ret = vDecSample2->DecodeSetSurface();
904     ASSERT_EQ(AV_ERR_OK, ret);
905     vDecSample2->outputCallbackFlush = true;
906     ret = vDecSample2->StartVideoDecoder();
907     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
908     ASSERT_EQ(AV_ERR_OK, ret);
909     vDecSample2->WaitForEOS();
910 }
911 
912 /**
913  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3800
914  * @tc.name      : Flush or stop in buffe decoder callback function-surface
915  * @tc.desc      : function test
916  */
917 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3800, TestSize.Level1)
918 {
919     vDecSample2->SF_OUTPUT = true;
920     int32_t ret = vDecSample2->DecodeSetSurface();
921     ASSERT_EQ(AV_ERR_OK, ret);
922     vDecSample2->outputCallbackStop = true;
923     ret = vDecSample2->StartVideoDecoder();
924     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
925     ASSERT_EQ(AV_ERR_OK, ret);
926     vDecSample2->WaitForEOS();
927 }
928 
929 /**
930  * @tc.number    : HEVC_HW_HDR2SDR_STATE_3900
931  * @tc.name      : Flush or stop in surf decoder callback function-surface
932  * @tc.desc      : function test
933  */
934 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3900, TestSize.Level1)
935 {
936     vDecSample2->SF_OUTPUT = true;
937     int32_t ret = vDecSample2->DecodeSetSurface();
938     ASSERT_EQ(AV_ERR_OK, ret);
939     vDecSample2->SF_OUTPUT = true;
940     vDecSample2->inputCallbackFlush = true;
941     ret = vDecSample2->StartVideoDecoder();
942     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
943     vDecSample2->WaitForEOS();
944     ASSERT_EQ(AV_ERR_OK, ret);
945 }
946 
947 /**
948  * @tc.number    : HEVC_HW_HDR2SDR_STATE_4000
949  * @tc.name      : Flush or stop in buffe decoder callback function-surface
950  * @tc.desc      : function test
951  */
952 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4000, TestSize.Level1)
953 {
954     vDecSample2->SF_OUTPUT = true;
955     int32_t ret = vDecSample2->DecodeSetSurface();
956     ASSERT_EQ(AV_ERR_OK, ret);
957     vDecSample2->SF_OUTPUT = true;
958     vDecSample2->inputCallbackStop = true;
959     ret = vDecSample2->StartVideoDecoder();
960     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
961     ASSERT_EQ(AV_ERR_OK, ret);
962     vDecSample2->WaitForEOS();
963 }
964 
965 /**
966  * @tc.number    : HEVC_HW_HDR2SDR_STATE_4100
967  * @tc.name      : Flush or stop in buffe decoder callback function-surface
968  * @tc.desc      : function test
969  */
970 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4100, TestSize.Level1)
971 {
972     vDecSample2->SF_OUTPUT = true;
973     int32_t ret = vDecSample2->DecodeSetSurface();
974     ASSERT_EQ(AV_ERR_OK, ret);
975     vDecSample2->SF_OUTPUT = true;
976     vDecSample2->outputCallbackFlush = true;
977     ret = vDecSample2->StartVideoDecoder();
978     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
979     ASSERT_EQ(AV_ERR_OK, ret);
980     vDecSample2->WaitForEOS();
981 }
982 
983 /**
984  * @tc.number    : HEVC_HW_HDR2SDR_STATE_4200
985  * @tc.name      : Flush or stop in buffe decoder callback function-surface
986  * @tc.desc      : function test
987  */
988 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4200, TestSize.Level1)
989 {
990     vDecSample2->SF_OUTPUT = true;
991     int32_t ret = vDecSample2->DecodeSetSurface();
992     ASSERT_EQ(AV_ERR_OK, ret);
993     vDecSample2->SF_OUTPUT = true;
994     vDecSample2->outputCallbackStop = true;
995     ret = vDecSample2->StartVideoDecoder();
996     vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
997     ASSERT_EQ(AV_ERR_OK, ret);
998     vDecSample2->WaitForEOS();
999 }
1000 } //namespace