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 "videoenc_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 HwEncStateNdkTest : 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 HwEncStateNdkTest::SetUpTestCase(void) {}
53 
TearDownTestCase(void)54 void HwEncStateNdkTest::TearDownTestCase(void) {}
55 
56 VEncNdkSample *vEncSample = NULL;
57 
SetUp(void)58 void HwEncStateNdkTest::SetUp(void)
59 {
60     vEncSample = new VEncNdkSample();
61     cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
62     const char *codeName = OH_AVCapability_GetName(cap);
63     cout << "codecname: " << codeName << endl;
64     int32_t ret = vEncSample->CreateVideoEncoder(codeName);
65     ASSERT_EQ(AV_ERR_OK, ret);
66     ret = vEncSample->SetVideoEncoderCallback();
67     ASSERT_EQ(AV_ERR_OK, ret);
68     ret = vEncSample->ConfigureVideoEncoder();
69     ASSERT_EQ(AV_ERR_OK, ret);
70     vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
71 }
72 
TearDown(void)73 void HwEncStateNdkTest::TearDown(void)
74 {
75     vEncSample->Release();
76     delete vEncSample;
77     vEncSample = nullptr;
78 }
79 } // namespace Media
80 } // namespace OHOS
81 
82 namespace {
83 /**
84  * @tc.number    : VIDEO_ENCODE_STATE_0100
85  * @tc.name      : create-configure-error
86  * @tc.desc      : function test
87  */
88 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0100, TestSize.Level2)
89 {
90     int32_t ret = vEncSample->Flush();
91     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
92     ret = vEncSample->SetVideoEncoderCallback();
93     ASSERT_EQ(AV_ERR_OK, ret);
94 }
95 
96 /**
97  * @tc.number    : VIDEO_ENCODE_STATE_0101
98  * @tc.name      : create-configure-stop
99  * @tc.desc      : function test
100  */
101 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0101, TestSize.Level2)
102 {
103     int32_t ret = vEncSample->Stop();
104     ASSERT_EQ(AV_ERR_OK, ret);
105 }
106 
107 /**
108  * @tc.number    : VIDEO_ENCODE_STATE_0200
109  * @tc.name      : create-configure-start-stop-start
110  * @tc.desc      : function test
111  */
112 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0200, TestSize.Level2)
113 {
114     int32_t ret = vEncSample->Start();
115     ASSERT_EQ(AV_ERR_OK, ret);
116     ret = vEncSample->Stop();
117     ASSERT_EQ(AV_ERR_OK, ret);
118     ret = vEncSample->Start();
119     ASSERT_EQ(AV_ERR_OK, ret);
120 }
121 
122 /**
123  * @tc.number    : VIDEO_ENCODE_STATE_0300
124  * @tc.name      : create-configure-start-stop-release
125  * @tc.desc      : function test
126  */
127 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0300, TestSize.Level2)
128 {
129     int32_t ret = vEncSample->Start();
130     ASSERT_EQ(AV_ERR_OK, ret);
131     ret = vEncSample->Stop();
132     ASSERT_EQ(AV_ERR_OK, ret);
133     ret = vEncSample->Release();
134     ASSERT_EQ(AV_ERR_OK, ret);
135 }
136 
137 /**
138  * @tc.number    : VIDEO_ENCODE_STATE_0400
139  * @tc.name      : create-configure-start-stop-reset
140  * @tc.desc      : function test
141  */
142 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0400, TestSize.Level2)
143 {
144     int32_t ret = vEncSample->Start();
145     ASSERT_EQ(AV_ERR_OK, ret);
146     ret = vEncSample->Stop();
147     ASSERT_EQ(AV_ERR_OK, ret);
148     ret = vEncSample->Reset();
149     ASSERT_EQ(AV_ERR_OK, ret);
150 }
151 
152 /**
153  * @tc.number    : VIDEO_ENCODE_STATE_0500CODEC_NAME_AVC
154  * @tc.name      : create-configure-start-stop-error
155  * @tc.desc      : function test
156  */
157 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0500, TestSize.Level2)
158 {
159     int32_t ret = vEncSample->Start();
160     ASSERT_EQ(AV_ERR_OK, ret);
161     ret = vEncSample->Stop();
162     ASSERT_EQ(AV_ERR_OK, ret);
163     ret = vEncSample->Flush();
164     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
165     ret = vEncSample->SetVideoEncoderCallback();
166     ASSERT_EQ(AV_ERR_OK, ret);
167 }
168 
169 /**
170  * @tc.number    : VIDEO_ENCODE_STATE_0600
171  * @tc.name      : create-configure-start-EOS-stop-start
172  * @tc.desc      : function test
173  */
174 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0600, TestSize.Level2)
175 {
176     int32_t ret = vEncSample->StartVideoEncoder();
177     ASSERT_EQ(AV_ERR_OK, ret);
178     vEncSample->WaitForEOS();
179     ASSERT_EQ(AV_ERR_OK, ret);
180     ASSERT_EQ(0, vEncSample->errCount);
181     ret = vEncSample->Stop();
182     ASSERT_EQ(AV_ERR_OK, ret);
183     ret = vEncSample->Start();
184     ASSERT_EQ(AV_ERR_OK, ret);
185 }
186 
187 /**
188  * @tc.number    : VIDEO_ENCODE_STATE_0700
189  * @tc.name      : create-configure-start-EOS-stop-release
190  * @tc.desc      : function test
191  */
192 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0700, TestSize.Level2)
193 {
194     int32_t ret = vEncSample->StartVideoEncoder();
195     vEncSample->WaitForEOS();
196     ASSERT_EQ(AV_ERR_OK, ret);
197     ASSERT_EQ(0, vEncSample->errCount);
198     ret = vEncSample->Stop();
199     ASSERT_EQ(AV_ERR_OK, ret);
200     ret = vEncSample->Release();
201     ASSERT_EQ(AV_ERR_OK, ret);
202 }
203 
204 /**
205  * @tc.number    : VIDEO_ENCODE_STATE_0800
206  * @tc.name      : create-configure-start-EOS-stop-reset
207  * @tc.desc      : function test
208  */
209 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0800, TestSize.Level2)
210 {
211     int32_t ret = vEncSample->StartVideoEncoder();
212     ASSERT_EQ(AV_ERR_OK, ret);
213     vEncSample->WaitForEOS();
214     ASSERT_EQ(AV_ERR_OK, ret);
215     ASSERT_EQ(0, vEncSample->errCount);
216     ret = vEncSample->Stop();
217     ASSERT_EQ(AV_ERR_OK, ret);
218     ret = vEncSample->Reset();
219     ASSERT_EQ(AV_ERR_OK, ret);
220 }
221 
222 /**
223  * @tc.number    : VIDEO_ENCODE_STATE_0900
224  * @tc.name      : create-configure-start-EOS-flush
225  * @tc.desc      : function test
226  */
227 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0900, TestSize.Level2)
228 {
229     int32_t ret = vEncSample->StartVideoEncoder();
230     vEncSample->WaitForEOS();
231     ASSERT_EQ(AV_ERR_OK, ret);
232     ASSERT_EQ(0, vEncSample->errCount);
233     ret = vEncSample->Flush();
234     ASSERT_EQ(AV_ERR_OK, ret);
235 }
236 
237 /**
238  * @tc.number    : VIDEO_ENCODE_STATE_1000
239  * @tc.name      : create-configure-start-EOS-flush-start
240  * @tc.desc      : function test
241  */
242 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1000, TestSize.Level2)
243 {
244     int32_t ret = vEncSample->StartVideoEncoder();
245     vEncSample->WaitForEOS();
246     ASSERT_EQ(AV_ERR_OK, ret);
247     ASSERT_EQ(0, vEncSample->errCount);
248     ret = vEncSample->Flush();
249     ASSERT_EQ(AV_ERR_OK, ret);
250     ret = vEncSample->Start();
251     ASSERT_EQ(AV_ERR_OK, ret);
252 }
253 
254 /**
255  * @tc.number    : VIDEO_ENCODE_STATE_1100
256  * @tc.name      : create-configure-start-EOS-flush-stop
257  * @tc.desc      : function test
258  */
259 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1100, TestSize.Level2)
260 {
261     int32_t ret = vEncSample->StartVideoEncoder();
262     vEncSample->WaitForEOS();
263     ASSERT_EQ(AV_ERR_OK, ret);
264     ASSERT_EQ(0, vEncSample->errCount);
265     ret = vEncSample->Flush();
266     ASSERT_EQ(AV_ERR_OK, ret);
267     ret = vEncSample->Stop();
268     ASSERT_EQ(AV_ERR_OK, ret);
269 }
270 
271 /**
272  * @tc.number    : VIDEO_ENCODE_STATE_1200
273  * @tc.name      : create-configure-start-EOS-flush-reset
274  * @tc.desc      : function test
275  */
276 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1200, TestSize.Level2)
277 {
278     int32_t ret = vEncSample->StartVideoEncoder();
279     vEncSample->WaitForEOS();
280     ASSERT_EQ(AV_ERR_OK, ret);
281     ASSERT_EQ(0, vEncSample->errCount);
282     ret = vEncSample->Flush();
283     ASSERT_EQ(AV_ERR_OK, ret);
284     ret = vEncSample->Reset();
285     ASSERT_EQ(AV_ERR_OK, ret);
286 }
287 
288 /**
289  * @tc.number    : VIDEO_ENCODE_STATE_1300
290  * @tc.name      : create-configure-start-EOS-flush-error
291  * @tc.desc      : function test
292  */
293 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1300, TestSize.Level2)
294 {
295     int32_t ret = vEncSample->StartVideoEncoder();
296     vEncSample->WaitForEOS();
297     ASSERT_EQ(AV_ERR_OK, ret);
298     ASSERT_EQ(0, vEncSample->errCount);
299     ret = vEncSample->Flush();
300     ASSERT_EQ(AV_ERR_OK, ret);
301     ret = vEncSample->Release();
302     ASSERT_EQ(AV_ERR_OK, ret);
303     ret = vEncSample->ConfigureVideoEncoder();
304     ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
305 }
306 
307 /**
308  * @tc.number    : VIDEO_ENCODE_STATE_1400
309  * @tc.name      : create-configure-start-EOS-reset-configure
310  * @tc.desc      : function test
311  */
312 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1400, TestSize.Level2)
313 {
314     int32_t ret = vEncSample->StartVideoEncoder();
315     vEncSample->WaitForEOS();
316     ASSERT_EQ(AV_ERR_OK, ret);
317     ASSERT_EQ(0, vEncSample->errCount);
318     ret = vEncSample->Reset();
319     ASSERT_EQ(AV_ERR_OK, ret);
320     ret = vEncSample->ConfigureVideoEncoder();
321     ASSERT_EQ(AV_ERR_OK, ret);
322 }
323 
324 /**
325  * @tc.number    : VIDEO_ENCODE_STATE_1500
326  * @tc.name      : create-configure-start-EOS-reset-release
327  * @tc.desc      : function test
328  */
329 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1500, TestSize.Level2)
330 {
331     int32_t ret = vEncSample->StartVideoEncoder();
332     vEncSample->WaitForEOS();
333     ASSERT_EQ(AV_ERR_OK, ret);
334     ASSERT_EQ(0, vEncSample->errCount);
335     ret = vEncSample->Reset();
336     ASSERT_EQ(AV_ERR_OK, ret);
337     ret = vEncSample->Release();
338     ASSERT_EQ(AV_ERR_OK, ret);
339 }
340 
341 /**
342  * @tc.number    : VIDEO_ENCODE_STATE_1600
343  * @tc.name      : create-configure-start-EOS-reset-error
344  * @tc.desc      : function test
345  */
346 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1600, TestSize.Level2)
347 {
348     int32_t ret = vEncSample->StartVideoEncoder();
349     vEncSample->WaitForEOS();
350     ASSERT_EQ(AV_ERR_OK, ret);
351     ASSERT_EQ(0, vEncSample->errCount);
352     ret = vEncSample->Reset();
353     ASSERT_EQ(AV_ERR_OK, ret);
354     ret = vEncSample->Start();
355     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
356     ret = vEncSample->Stop();
357     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
358     ret = vEncSample->Flush();
359     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
360 }
361 
362 /**
363  * @tc.number    : VIDEO_ENCODE_STATE_1700
364  * @tc.name      : create-configure-start-flush-start-flush
365  * @tc.desc      : function test
366  */
367 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1700, TestSize.Level2)
368 {
369     int32_t ret = vEncSample->Start();
370     ASSERT_EQ(AV_ERR_OK, ret);
371     ret = vEncSample->Flush();
372     ASSERT_EQ(AV_ERR_OK, ret);
373     ret = vEncSample->Start();
374     ASSERT_EQ(AV_ERR_OK, ret);
375     ret = vEncSample->Flush();
376     ASSERT_EQ(AV_ERR_OK, ret);
377 }
378 
379 /**
380  * @tc.number    : VIDEO_ENCODE_STATE_1800
381  * @tc.name      : create-configure-start-flush-start-eos
382  * @tc.desc      : function test
383  */
384 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1800, TestSize.Level2)
385 {
386     int32_t ret = vEncSample->Start();
387     ASSERT_EQ(AV_ERR_OK, ret);
388     ret = vEncSample->Flush();
389     ASSERT_EQ(AV_ERR_OK, ret);
390     cout << "flush ok" << endl;
391     ret = vEncSample->Start();
392     ASSERT_EQ(AV_ERR_OK, ret);
393     cout << "start ok" << endl;
394     ret = vEncSample->state_EOS();
395     ASSERT_EQ(AV_ERR_OK, ret);
396 }
397 
398 /**
399  * @tc.number    : VIDEO_ENCODE_STATE_1900
400  * @tc.name      : create-configure-start-flush-start-stop
401  * @tc.desc      : function test
402  */
403 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1900, TestSize.Level2)
404 {
405     int32_t ret = vEncSample->Start();
406     ASSERT_EQ(AV_ERR_OK, ret);
407     ret = vEncSample->Flush();
408     ASSERT_EQ(AV_ERR_OK, ret);
409     ret = vEncSample->Start();
410     ASSERT_EQ(AV_ERR_OK, ret);
411     ret = vEncSample->Stop();
412     ASSERT_EQ(AV_ERR_OK, ret);
413 }
414 
415 /**
416  * @tc.number    : VIDEO_ENCODE_STATE_2000
417  * @tc.name      : create-configure-start-flush-start-reset
418  * @tc.desc      : function test
419  */
420 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2000, TestSize.Level2)
421 {
422     int32_t ret = vEncSample->Start();
423     ASSERT_EQ(AV_ERR_OK, ret);
424     ret = vEncSample->Flush();
425     ASSERT_EQ(AV_ERR_OK, ret);
426     ret = vEncSample->Start();
427     ASSERT_EQ(AV_ERR_OK, ret);
428     ret = vEncSample->Reset();
429     ASSERT_EQ(AV_ERR_OK, ret);
430 }
431 
432 /**
433  * @tc.number    : VIDEO_ENCODE_STATE_2100
434  * @tc.name      : create-configure-start-flush-start-error
435  * @tc.desc      : function test
436  */
437 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2100, TestSize.Level2)
438 {
439     int32_t ret = vEncSample->Start();
440     ASSERT_EQ(AV_ERR_OK, ret);
441     ret = vEncSample->Flush();
442     ASSERT_EQ(AV_ERR_OK, ret);
443     ret = vEncSample->Start();
444     ASSERT_EQ(AV_ERR_OK, ret);
445     ret = vEncSample->ConfigureVideoEncoder();
446     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
447     ret = vEncSample->SetVideoEncoderCallback();
448     ASSERT_EQ(AV_ERR_OK, ret);
449     ret = vEncSample->Release();
450     ASSERT_EQ(AV_ERR_OK, ret);
451 }
452 
453 /**
454  * @tc.number    : VIDEO_ENCODE_STATE_2200
455  * @tc.name      : create-configure-start-flush-start-error
456  * @tc.desc      : function test
457  */
458 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2200, TestSize.Level2)
459 {
460     int32_t ret = vEncSample->Start();
461     ASSERT_EQ(AV_ERR_OK, ret);
462     ret = vEncSample->Flush();
463     ASSERT_EQ(AV_ERR_OK, ret);
464     ret = vEncSample->Stop();
465     ASSERT_EQ(AV_ERR_OK, ret);
466     ret = vEncSample->Start();
467     ASSERT_EQ(AV_ERR_OK, ret);
468     cout << "set callback" << endl;
469     ret = vEncSample->SetVideoEncoderCallback();
470     ASSERT_EQ(AV_ERR_OK, ret);
471 }
472 
473 /**
474  * @tc.number    : VIDEO_ENCODE_STATE_2300
475  * @tc.name      : create-configure-start-flush-stop-start
476  * @tc.desc      : function test
477  */
478 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2300, TestSize.Level2)
479 {
480     int32_t ret = vEncSample->Start();
481     ASSERT_EQ(AV_ERR_OK, ret);
482     ret = vEncSample->Flush();
483     ASSERT_EQ(AV_ERR_OK, ret);
484     ret = vEncSample->Stop();
485     ASSERT_EQ(AV_ERR_OK, ret);
486     ret = vEncSample->Release();
487     ASSERT_EQ(AV_ERR_OK, ret);
488 }
489 
490 /**
491  * @tc.number    : VIDEO_ENCODE_STATE_2400
492  * @tc.name      : create-configure-start-flush-stop-reset
493  * @tc.desc      : function test
494  */
495 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2400, TestSize.Level2)
496 {
497     int32_t ret = vEncSample->Start();
498     ASSERT_EQ(AV_ERR_OK, ret);
499     ret = vEncSample->Flush();
500     ASSERT_EQ(AV_ERR_OK, ret);
501     ret = vEncSample->Stop();
502     ASSERT_EQ(AV_ERR_OK, ret);
503     ret = vEncSample->Reset();
504     ASSERT_EQ(AV_ERR_OK, ret);
505 }
506 
507 /**
508  * @tc.number    : VIDEO_ENCODE_STATE_2500
509  * @tc.name      : create-configure-start-flush-stop-error
510  * @tc.desc      : function test
511  */
512 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2500, TestSize.Level2)
513 {
514     int32_t ret = vEncSample->Start();
515     ASSERT_EQ(AV_ERR_OK, ret);
516     ret = vEncSample->Flush();
517     ASSERT_EQ(AV_ERR_OK, ret);
518     ret = vEncSample->Stop();
519     ASSERT_EQ(AV_ERR_OK, ret);
520     ret = vEncSample->Flush();
521     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
522     ret = vEncSample->SetVideoEncoderCallback();
523     ASSERT_EQ(AV_ERR_OK, ret);
524 }
525 
526 /**
527  * @tc.number    : VIDEO_ENCODE_STATE_2600
528  * @tc.name      : create-configure-start-flush-reset-configure
529  * @tc.desc      : function test
530  */
531 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2600, TestSize.Level2)
532 {
533     int32_t ret = vEncSample->Start();
534     ASSERT_EQ(AV_ERR_OK, ret);
535     ret = vEncSample->Flush();
536     ASSERT_EQ(AV_ERR_OK, ret);
537     ret = vEncSample->Reset();
538     ASSERT_EQ(AV_ERR_OK, ret);
539     ret = vEncSample->ConfigureVideoEncoder();
540     ASSERT_EQ(AV_ERR_OK, ret);
541 }
542 
543 /**
544  * @tc.number    : VIDEO_ENCODE_STATE_2700
545  * @tc.name      : create-configure-start-flush-reset-release
546  * @tc.desc      : function test
547  */
548 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2700, TestSize.Level2)
549 {
550     int32_t ret = vEncSample->Start();
551     ASSERT_EQ(AV_ERR_OK, ret);
552     ret = vEncSample->Flush();
553     ASSERT_EQ(AV_ERR_OK, ret);
554     ret = vEncSample->Reset();
555     ASSERT_EQ(AV_ERR_OK, ret);
556     ret = vEncSample->Release();
557     ASSERT_EQ(AV_ERR_OK, ret);
558 }
559 
560 /**
561  * @tc.number    : VIDEO_ENCODE_STATE_2800
562  * @tc.name      : create-configure-start-flush-reset-error
563  * @tc.desc      : function test
564  */
565 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2800, TestSize.Level2)
566 {
567     int32_t ret = vEncSample->Start();
568     ASSERT_EQ(AV_ERR_OK, ret);
569     ret = vEncSample->Flush();
570     ASSERT_EQ(AV_ERR_OK, ret);
571     ret = vEncSample->Reset();
572     ASSERT_EQ(AV_ERR_OK, ret);
573     ret = vEncSample->Start();
574     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
575     ret = vEncSample->Stop();
576     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
577     ret = vEncSample->Flush();
578     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
579     ret = vEncSample->SetVideoEncoderCallback();
580     ASSERT_EQ(AV_ERR_OK, ret);
581 }
582 
583 /**
584  * @tc.number    : VIDEO_ENCODE_STATE_2900
585  * @tc.name      : create-configure-start-reset-configure
586  * @tc.desc      : function test
587  */
588 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2900, TestSize.Level2)
589 {
590     int32_t ret = vEncSample->Start();
591     ASSERT_EQ(AV_ERR_OK, ret);
592     ret = vEncSample->Reset();
593     ASSERT_EQ(AV_ERR_OK, ret);
594     ret = vEncSample->ConfigureVideoEncoder();
595     ASSERT_EQ(AV_ERR_OK, ret);
596 }
597 
598 /**
599  * @tc.number    : VIDEO_ENCODE_STATE_3000
600  * @tc.name      : create-configure-start-reset-release
601  * @tc.desc      : function test
602  */
603 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3000, TestSize.Level2)
604 {
605     int32_t ret = vEncSample->Start();
606     ASSERT_EQ(AV_ERR_OK, ret);
607     ret = vEncSample->Reset();
608     ASSERT_EQ(AV_ERR_OK, ret);
609     ret = vEncSample->Release();
610     ASSERT_EQ(AV_ERR_OK, ret);
611 }
612 
613 /**
614  * @tc.number    : VIDEO_ENCODE_STATE_3100
615  * @tc.name      : create-configure-start-reset-error
616  * @tc.desc      : function test
617  */
618 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3100, TestSize.Level2)
619 {
620     int32_t ret = vEncSample->Start();
621     ASSERT_EQ(AV_ERR_OK, ret);
622     ret = vEncSample->Reset();
623     ASSERT_EQ(AV_ERR_OK, ret);
624     ret = vEncSample->Start();
625     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
626     ret = vEncSample->Stop();
627     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
628     ret = vEncSample->Flush();
629     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
630     ret = vEncSample->SetVideoEncoderCallback();
631     ASSERT_EQ(AV_ERR_OK, ret);
632 }
633 
634 /**
635  * @tc.number    : VIDEO_ENCODE_STATE_3200
636  * @tc.name      : create-configure-start-error
637  * @tc.desc      : function test
638  */
639 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3200, TestSize.Level2)
640 {
641     int32_t ret = vEncSample->Start();
642     ASSERT_EQ(AV_ERR_OK, ret);
643     ret = vEncSample->ConfigureVideoEncoder();
644     ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
645     ret = vEncSample->SetVideoEncoderCallback();
646     ASSERT_EQ(AV_ERR_OK, ret);
647     ret = vEncSample->Release();
648     ASSERT_EQ(AV_ERR_OK, ret);
649 }
650 
651 /**
652  * @tc.number    : VIDEO_ENCODE_STATE_3300
653  * @tc.name      : create-configure-reset-configure
654  * @tc.desc      : function test
655  */
656 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3300, TestSize.Level2)
657 {
658     int32_t ret = vEncSample->Reset();
659     ASSERT_EQ(AV_ERR_OK, ret);
660     ret = vEncSample->ConfigureVideoEncoder();
661     ASSERT_EQ(AV_ERR_OK, ret);
662 }
663 
664 /**
665  * @tc.number    : VIDEO_ENCODE_STATE_3400
666  * @tc.name      : create-configure-release
667  * @tc.desc      : function test
668  */
669 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3400, TestSize.Level2)
670 {
671     int32_t ret = vEncSample->Release();
672     ASSERT_EQ(AV_ERR_OK, ret);
673 }
674 
675 /**
676  * @tc.number    : VIDEO_ENCODE_STATE_3500
677  * @tc.name      : Flush in surf encode callback function
678  * @tc.desc      : function test
679  */
680 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3500, TestSize.Level1)
681 {
682     vEncSample->outputCallbackFlush = true;
683     vEncSample->SURF_INPUT = true;
684     int32_t ret = vEncSample->StartVideoEncoder();
685     ASSERT_EQ(AV_ERR_OK, ret);
686     vEncSample->WaitForEOS();
687 }
688 
689 /**
690  * @tc.number    : VIDEO_ENCODE_STATE_3600
691  * @tc.name      : Stop in surf encode callback function
692  * @tc.desc      : function test
693  */
694 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3600, TestSize.Level1)
695 {
696     vEncSample->outputCallbackStop = true;
697     vEncSample->SURF_INPUT = true;
698     int32_t ret = vEncSample->StartVideoEncoder();
699     ASSERT_EQ(AV_ERR_OK, ret);
700     vEncSample->WaitForEOS();
701 }
702 
703 /**
704  * @tc.number    : VIDEO_ENCODE_STATE_3700
705  * @tc.name      : Flush or stop in buffer encode callback function
706  * @tc.desc      : function test
707  */
708 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3700, TestSize.Level1)
709 {
710     vEncSample->inputCallbackFlush = true;
711     int32_t ret = vEncSample->StartVideoEncoder();
712     ASSERT_EQ(AV_ERR_OK, ret);
713     vEncSample->WaitForEOS();
714 }
715 
716 /**
717  * @tc.number    : VIDEO_ENCODE_STATE_3800
718  * @tc.name      : Flush or stop in buffer encode callback function
719  * @tc.desc      : function test
720  */
721 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3800, TestSize.Level1)
722 {
723     vEncSample->inputCallbackStop = true;
724     int32_t ret = vEncSample->StartVideoEncoder();
725     ASSERT_EQ(AV_ERR_OK, ret);
726     vEncSample->WaitForEOS();
727 }
728 
729 /**
730  * @tc.number    : VIDEO_ENCODE_STATE_3900
731  * @tc.name      : Flush or stop in buffer encode callback function
732  * @tc.desc      : function test
733  */
734 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3900, TestSize.Level1)
735 {
736     vEncSample->outputCallbackFlush = true;
737     int32_t ret = vEncSample->StartVideoEncoder();
738     ASSERT_EQ(AV_ERR_OK, ret);
739     vEncSample->WaitForEOS();
740 }
741 
742 /**
743  * @tc.number    : VIDEO_ENCODE_STATE_4000
744  * @tc.name      : Flush or stop in buffer encode callback function
745  * @tc.desc      : function test
746  */
747 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_4000, TestSize.Level1)
748 {
749     vEncSample->outputCallbackStop = true;
750     int32_t ret = vEncSample->StartVideoEncoder();
751     ASSERT_EQ(AV_ERR_OK, ret);
752     vEncSample->WaitForEOS();
753 }
754 } // namespace