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 cap = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, true, HARDWARE);
61 if (cap != nullptr) {
62 vEncSample = new VEncNdkSample();
63 const char *codeName = OH_AVCapability_GetName(cap);
64 cout << "codecname: " << codeName << endl;
65 int32_t ret = vEncSample->CreateVideoEncoder(codeName);
66 ASSERT_EQ(AV_ERR_OK, ret);
67 ret = vEncSample->SetVideoEncoderCallback();
68 ASSERT_EQ(AV_ERR_OK, ret);
69 ret = vEncSample->ConfigureVideoEncoder();
70 ASSERT_EQ(AV_ERR_OK, ret);
71 vEncSample->INP_DIR = "/data/test/media/1280_720_nv.yuv";
72 }
73 }
74
TearDown(void)75 void HwEncStateNdkTest::TearDown(void)
76 {
77 if (cap != nullptr) {
78 vEncSample->Release();
79 delete vEncSample;
80 vEncSample = nullptr;
81 }
82 }
83 } // namespace Media
84 } // namespace OHOS
85
86 namespace {
87 /**
88 * @tc.number : VIDEO_ENCODE_STATE_0100
89 * @tc.name : create-configure-error
90 * @tc.desc : function test
91 */
92 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0100, TestSize.Level2)
93 {
94 if (cap != nullptr) {
95 int32_t ret = vEncSample->Flush();
96 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
97 ret = vEncSample->SetVideoEncoderCallback();
98 ASSERT_EQ(AV_ERR_OK, ret);
99 }
100 else {
101 return;
102 }
103 }
104
105 /**
106 * @tc.number : VIDEO_ENCODE_STATE_0101
107 * @tc.name : create-configure-stop
108 * @tc.desc : function test
109 */
110 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0101, TestSize.Level2)
111 {
112 if (cap != nullptr) {
113 int32_t ret = vEncSample->Stop();
114 ASSERT_EQ(AV_ERR_OK, ret);
115 }
116 else {
117 return;
118 }
119 }
120
121 /**
122 * @tc.number : VIDEO_ENCODE_STATE_0200
123 * @tc.name : create-configure-start-stop-start
124 * @tc.desc : function test
125 */
126 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0200, TestSize.Level2)
127 {
128 if (cap != nullptr) {
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->Start();
134 ASSERT_EQ(AV_ERR_OK, ret);
135 }
136 else {
137 return;
138 }
139 }
140
141 /**
142 * @tc.number : VIDEO_ENCODE_STATE_0300
143 * @tc.name : create-configure-start-stop-release
144 * @tc.desc : function test
145 */
146 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0300, TestSize.Level2)
147 {
148 if (cap != nullptr) {
149 int32_t ret = vEncSample->Start();
150 ASSERT_EQ(AV_ERR_OK, ret);
151 ret = vEncSample->Stop();
152 ASSERT_EQ(AV_ERR_OK, ret);
153 ret = vEncSample->Release();
154 ASSERT_EQ(AV_ERR_OK, ret);
155 }
156 else {
157 return;
158 }
159 }
160
161 /**
162 * @tc.number : VIDEO_ENCODE_STATE_0400
163 * @tc.name : create-configure-start-stop-reset
164 * @tc.desc : function test
165 */
166 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0400, TestSize.Level2)
167 {
168 if (cap != nullptr) {
169 int32_t ret = vEncSample->Start();
170 ASSERT_EQ(AV_ERR_OK, ret);
171 ret = vEncSample->Stop();
172 ASSERT_EQ(AV_ERR_OK, ret);
173 ret = vEncSample->Reset();
174 ASSERT_EQ(AV_ERR_OK, ret);
175 }
176 else {
177 return;
178 }
179 }
180
181 /**
182 * @tc.number : VIDEO_ENCODE_STATE_0500CODEC_NAME_AVC
183 * @tc.name : create-configure-start-stop-error
184 * @tc.desc : function test
185 */
186 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0500, TestSize.Level2)
187 {
188 if (cap != nullptr) {
189 int32_t ret = vEncSample->Start();
190 ASSERT_EQ(AV_ERR_OK, ret);
191 ret = vEncSample->Stop();
192 ASSERT_EQ(AV_ERR_OK, ret);
193 ret = vEncSample->Flush();
194 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
195 ret = vEncSample->SetVideoEncoderCallback();
196 ASSERT_EQ(AV_ERR_OK, ret);
197 }
198 else {
199 return;
200 }
201 }
202
203 /**
204 * @tc.number : VIDEO_ENCODE_STATE_0600
205 * @tc.name : create-configure-start-EOS-stop-start
206 * @tc.desc : function test
207 */
208 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0600, TestSize.Level2)
209 {
210 if (cap != nullptr) {
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->Start();
219 ASSERT_EQ(AV_ERR_OK, ret);
220 }
221 else {
222 return;
223 }
224 }
225
226 /**
227 * @tc.number : VIDEO_ENCODE_STATE_0700
228 * @tc.name : create-configure-start-EOS-stop-release
229 * @tc.desc : function test
230 */
231 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0700, TestSize.Level2)
232 {
233 if (cap != nullptr) {
234 int32_t ret = vEncSample->StartVideoEncoder();
235 vEncSample->WaitForEOS();
236 ASSERT_EQ(AV_ERR_OK, ret);
237 ASSERT_EQ(0, vEncSample->errCount);
238 ret = vEncSample->Stop();
239 ASSERT_EQ(AV_ERR_OK, ret);
240 ret = vEncSample->Release();
241 ASSERT_EQ(AV_ERR_OK, ret);
242 }
243 else {
244 return;
245 }
246 }
247
248 /**
249 * @tc.number : VIDEO_ENCODE_STATE_0800
250 * @tc.name : create-configure-start-EOS-stop-reset
251 * @tc.desc : function test
252 */
253 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0800, TestSize.Level2)
254 {
255 if (cap != nullptr) {
256 int32_t ret = vEncSample->StartVideoEncoder();
257 ASSERT_EQ(AV_ERR_OK, ret);
258 vEncSample->WaitForEOS();
259 ASSERT_EQ(AV_ERR_OK, ret);
260 ASSERT_EQ(0, vEncSample->errCount);
261 ret = vEncSample->Stop();
262 ASSERT_EQ(AV_ERR_OK, ret);
263 ret = vEncSample->Reset();
264 ASSERT_EQ(AV_ERR_OK, ret);
265 }
266 else {
267 return;
268 }
269 }
270
271 /**
272 * @tc.number : VIDEO_ENCODE_STATE_0900
273 * @tc.name : create-configure-start-EOS-flush
274 * @tc.desc : function test
275 */
276 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_0900, TestSize.Level2)
277 {
278 if (cap != nullptr) {
279 int32_t ret = vEncSample->StartVideoEncoder();
280 vEncSample->WaitForEOS();
281 ASSERT_EQ(AV_ERR_OK, ret);
282 ASSERT_EQ(0, vEncSample->errCount);
283 ret = vEncSample->Flush();
284 ASSERT_EQ(AV_ERR_OK, ret);
285 }
286 else {
287 return;
288 }
289 }
290
291 /**
292 * @tc.number : VIDEO_ENCODE_STATE_1000
293 * @tc.name : create-configure-start-EOS-flush-start
294 * @tc.desc : function test
295 */
296 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1000, TestSize.Level2)
297 {
298 if (cap != nullptr) {
299 int32_t ret = vEncSample->StartVideoEncoder();
300 vEncSample->WaitForEOS();
301 ASSERT_EQ(AV_ERR_OK, ret);
302 ASSERT_EQ(0, vEncSample->errCount);
303 ret = vEncSample->Flush();
304 ASSERT_EQ(AV_ERR_OK, ret);
305 ret = vEncSample->Start();
306 ASSERT_EQ(AV_ERR_OK, ret);
307 }
308 else {
309 return;
310 }
311 }
312
313 /**
314 * @tc.number : VIDEO_ENCODE_STATE_1100
315 * @tc.name : create-configure-start-EOS-flush-stop
316 * @tc.desc : function test
317 */
318 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1100, TestSize.Level2)
319 {
320 if (cap != nullptr) {
321 int32_t ret = vEncSample->StartVideoEncoder();
322 vEncSample->WaitForEOS();
323 ASSERT_EQ(AV_ERR_OK, ret);
324 ASSERT_EQ(0, vEncSample->errCount);
325 ret = vEncSample->Flush();
326 ASSERT_EQ(AV_ERR_OK, ret);
327 ret = vEncSample->Stop();
328 ASSERT_EQ(AV_ERR_OK, ret);
329 }
330 else {
331 return;
332 }
333 }
334
335 /**
336 * @tc.number : VIDEO_ENCODE_STATE_1200
337 * @tc.name : create-configure-start-EOS-flush-reset
338 * @tc.desc : function test
339 */
340 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1200, TestSize.Level2)
341 {
342 if (cap != nullptr) {
343 int32_t ret = vEncSample->StartVideoEncoder();
344 vEncSample->WaitForEOS();
345 ASSERT_EQ(AV_ERR_OK, ret);
346 ASSERT_EQ(0, vEncSample->errCount);
347 ret = vEncSample->Flush();
348 ASSERT_EQ(AV_ERR_OK, ret);
349 ret = vEncSample->Reset();
350 ASSERT_EQ(AV_ERR_OK, ret);
351 }
352 else {
353 return;
354 }
355 }
356
357 /**
358 * @tc.number : VIDEO_ENCODE_STATE_1300
359 * @tc.name : create-configure-start-EOS-flush-error
360 * @tc.desc : function test
361 */
362 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1300, TestSize.Level2)
363 {
364 if (cap != nullptr) {
365 int32_t ret = vEncSample->StartVideoEncoder();
366 vEncSample->WaitForEOS();
367 ASSERT_EQ(AV_ERR_OK, ret);
368 ASSERT_EQ(0, vEncSample->errCount);
369 ret = vEncSample->Flush();
370 ASSERT_EQ(AV_ERR_OK, ret);
371 ret = vEncSample->Release();
372 ASSERT_EQ(AV_ERR_OK, ret);
373 ret = vEncSample->ConfigureVideoEncoder();
374 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
375 }
376 else {
377 return;
378 }
379 }
380
381 /**
382 * @tc.number : VIDEO_ENCODE_STATE_1400
383 * @tc.name : create-configure-start-EOS-reset-configure
384 * @tc.desc : function test
385 */
386 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1400, TestSize.Level2)
387 {
388 if (cap != nullptr) {
389 int32_t ret = vEncSample->StartVideoEncoder();
390 vEncSample->WaitForEOS();
391 ASSERT_EQ(AV_ERR_OK, ret);
392 ASSERT_EQ(0, vEncSample->errCount);
393 ret = vEncSample->Reset();
394 ASSERT_EQ(AV_ERR_OK, ret);
395 ret = vEncSample->ConfigureVideoEncoder();
396 ASSERT_EQ(AV_ERR_OK, ret);
397 }
398 else {
399 return;
400 }
401 }
402
403 /**
404 * @tc.number : VIDEO_ENCODE_STATE_1500
405 * @tc.name : create-configure-start-EOS-reset-release
406 * @tc.desc : function test
407 */
408 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1500, TestSize.Level2)
409 {
410 if (cap != nullptr) {
411 int32_t ret = vEncSample->StartVideoEncoder();
412 vEncSample->WaitForEOS();
413 ASSERT_EQ(AV_ERR_OK, ret);
414 ASSERT_EQ(0, vEncSample->errCount);
415 ret = vEncSample->Reset();
416 ASSERT_EQ(AV_ERR_OK, ret);
417 ret = vEncSample->Release();
418 ASSERT_EQ(AV_ERR_OK, ret);
419 }
420 else {
421 return;
422 }
423 }
424
425 /**
426 * @tc.number : VIDEO_ENCODE_STATE_1600
427 * @tc.name : create-configure-start-EOS-reset-error
428 * @tc.desc : function test
429 */
430 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1600, TestSize.Level2)
431 {
432 if (cap != nullptr) {
433 int32_t ret = vEncSample->StartVideoEncoder();
434 vEncSample->WaitForEOS();
435 ASSERT_EQ(AV_ERR_OK, ret);
436 ASSERT_EQ(0, vEncSample->errCount);
437 ret = vEncSample->Reset();
438 ASSERT_EQ(AV_ERR_OK, ret);
439 ret = vEncSample->Start();
440 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
441 ret = vEncSample->Stop();
442 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
443 ret = vEncSample->Flush();
444 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
445 }
446 else {
447 return;
448 }
449 }
450
451 /**
452 * @tc.number : VIDEO_ENCODE_STATE_1700
453 * @tc.name : create-configure-start-flush-start-flush
454 * @tc.desc : function test
455 */
456 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1700, TestSize.Level2)
457 {
458 if (cap != nullptr) {
459 int32_t ret = vEncSample->Start();
460 ASSERT_EQ(AV_ERR_OK, ret);
461 ret = vEncSample->Flush();
462 ASSERT_EQ(AV_ERR_OK, ret);
463 ret = vEncSample->Start();
464 ASSERT_EQ(AV_ERR_OK, ret);
465 ret = vEncSample->Flush();
466 ASSERT_EQ(AV_ERR_OK, ret);
467 }
468 else {
469 return;
470 }
471 }
472
473 /**
474 * @tc.number : VIDEO_ENCODE_STATE_1800
475 * @tc.name : create-configure-start-flush-start-eos
476 * @tc.desc : function test
477 */
478 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1800, TestSize.Level2)
479 {
480 if (cap != nullptr) {
481 int32_t ret = vEncSample->Start();
482 ASSERT_EQ(AV_ERR_OK, ret);
483 ret = vEncSample->Flush();
484 ASSERT_EQ(AV_ERR_OK, ret);
485 cout << "flush ok" << endl;
486 ret = vEncSample->Start();
487 ASSERT_EQ(AV_ERR_OK, ret);
488 cout << "start ok" << endl;
489 ret = vEncSample->state_EOS();
490 ASSERT_EQ(AV_ERR_OK, ret);
491 }
492 else {
493 return;
494 }
495 }
496
497 /**
498 * @tc.number : VIDEO_ENCODE_STATE_1900
499 * @tc.name : create-configure-start-flush-start-stop
500 * @tc.desc : function test
501 */
502 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_1900, TestSize.Level2)
503 {
504 if (cap != nullptr) {
505 int32_t ret = vEncSample->Start();
506 ASSERT_EQ(AV_ERR_OK, ret);
507 ret = vEncSample->Flush();
508 ASSERT_EQ(AV_ERR_OK, ret);
509 ret = vEncSample->Start();
510 ASSERT_EQ(AV_ERR_OK, ret);
511 ret = vEncSample->Stop();
512 ASSERT_EQ(AV_ERR_OK, ret);
513 }
514 else {
515 return;
516 }
517 }
518
519 /**
520 * @tc.number : VIDEO_ENCODE_STATE_2000
521 * @tc.name : create-configure-start-flush-start-reset
522 * @tc.desc : function test
523 */
524 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2000, TestSize.Level2)
525 {
526 if (cap != nullptr) {
527 int32_t ret = vEncSample->Start();
528 ASSERT_EQ(AV_ERR_OK, ret);
529 ret = vEncSample->Flush();
530 ASSERT_EQ(AV_ERR_OK, ret);
531 ret = vEncSample->Start();
532 ASSERT_EQ(AV_ERR_OK, ret);
533 ret = vEncSample->Reset();
534 ASSERT_EQ(AV_ERR_OK, ret);
535 }
536 else {
537 return;
538 }
539 }
540
541 /**
542 * @tc.number : VIDEO_ENCODE_STATE_2100
543 * @tc.name : create-configure-start-flush-start-error
544 * @tc.desc : function test
545 */
546 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2100, TestSize.Level2)
547 {
548 if (cap != nullptr) {
549 int32_t ret = vEncSample->Start();
550 ASSERT_EQ(AV_ERR_OK, ret);
551 ret = vEncSample->Flush();
552 ASSERT_EQ(AV_ERR_OK, ret);
553 ret = vEncSample->Start();
554 ASSERT_EQ(AV_ERR_OK, ret);
555 ret = vEncSample->ConfigureVideoEncoder();
556 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
557 ret = vEncSample->SetVideoEncoderCallback();
558 ASSERT_EQ(AV_ERR_OK, ret);
559 ret = vEncSample->Release();
560 ASSERT_EQ(AV_ERR_OK, ret);
561 }
562 else {
563 return;
564 }
565 }
566
567 /**
568 * @tc.number : VIDEO_ENCODE_STATE_2200
569 * @tc.name : create-configure-start-flush-start-error
570 * @tc.desc : function test
571 */
572 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2200, TestSize.Level2)
573 {
574 if (cap != nullptr) {
575 int32_t ret = vEncSample->Start();
576 ASSERT_EQ(AV_ERR_OK, ret);
577 ret = vEncSample->Flush();
578 ASSERT_EQ(AV_ERR_OK, ret);
579 ret = vEncSample->Stop();
580 ASSERT_EQ(AV_ERR_OK, ret);
581 ret = vEncSample->Start();
582 ASSERT_EQ(AV_ERR_OK, ret);
583 cout << "set callback" << endl;
584 ret = vEncSample->SetVideoEncoderCallback();
585 ASSERT_EQ(AV_ERR_OK, ret);
586 }
587 else {
588 return;
589 }
590 }
591
592 /**
593 * @tc.number : VIDEO_ENCODE_STATE_2300
594 * @tc.name : create-configure-start-flush-stop-start
595 * @tc.desc : function test
596 */
597 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2300, TestSize.Level2)
598 {
599 if (cap != nullptr) {
600 int32_t ret = vEncSample->Start();
601 ASSERT_EQ(AV_ERR_OK, ret);
602 ret = vEncSample->Flush();
603 ASSERT_EQ(AV_ERR_OK, ret);
604 ret = vEncSample->Stop();
605 ASSERT_EQ(AV_ERR_OK, ret);
606 ret = vEncSample->Release();
607 ASSERT_EQ(AV_ERR_OK, ret);
608 }
609 else {
610 return;
611 }
612 }
613
614 /**
615 * @tc.number : VIDEO_ENCODE_STATE_2400
616 * @tc.name : create-configure-start-flush-stop-reset
617 * @tc.desc : function test
618 */
619 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2400, TestSize.Level2)
620 {
621 if (cap != nullptr) {
622 int32_t ret = vEncSample->Start();
623 ASSERT_EQ(AV_ERR_OK, ret);
624 ret = vEncSample->Flush();
625 ASSERT_EQ(AV_ERR_OK, ret);
626 ret = vEncSample->Stop();
627 ASSERT_EQ(AV_ERR_OK, ret);
628 ret = vEncSample->Reset();
629 ASSERT_EQ(AV_ERR_OK, ret);
630 }
631 else {
632 return;
633 }
634 }
635
636 /**
637 * @tc.number : VIDEO_ENCODE_STATE_2500
638 * @tc.name : create-configure-start-flush-stop-error
639 * @tc.desc : function test
640 */
641 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2500, TestSize.Level2)
642 {
643 if (cap != nullptr) {
644 int32_t ret = vEncSample->Start();
645 ASSERT_EQ(AV_ERR_OK, ret);
646 ret = vEncSample->Flush();
647 ASSERT_EQ(AV_ERR_OK, ret);
648 ret = vEncSample->Stop();
649 ASSERT_EQ(AV_ERR_OK, ret);
650 ret = vEncSample->Flush();
651 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
652 ret = vEncSample->SetVideoEncoderCallback();
653 ASSERT_EQ(AV_ERR_OK, ret);
654 }
655 else {
656 return;
657 }
658 }
659
660 /**
661 * @tc.number : VIDEO_ENCODE_STATE_2600
662 * @tc.name : create-configure-start-flush-reset-configure
663 * @tc.desc : function test
664 */
665 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2600, TestSize.Level2)
666 {
667 if (cap != nullptr) {
668 int32_t ret = vEncSample->Start();
669 ASSERT_EQ(AV_ERR_OK, ret);
670 ret = vEncSample->Flush();
671 ASSERT_EQ(AV_ERR_OK, ret);
672 ret = vEncSample->Reset();
673 ASSERT_EQ(AV_ERR_OK, ret);
674 ret = vEncSample->ConfigureVideoEncoder();
675 ASSERT_EQ(AV_ERR_OK, ret);
676 }
677 else {
678 return;
679 }
680 }
681
682 /**
683 * @tc.number : VIDEO_ENCODE_STATE_2700
684 * @tc.name : create-configure-start-flush-reset-release
685 * @tc.desc : function test
686 */
687 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2700, TestSize.Level2)
688 {
689 if (cap != nullptr) {
690 int32_t ret = vEncSample->Start();
691 ASSERT_EQ(AV_ERR_OK, ret);
692 ret = vEncSample->Flush();
693 ASSERT_EQ(AV_ERR_OK, ret);
694 ret = vEncSample->Reset();
695 ASSERT_EQ(AV_ERR_OK, ret);
696 ret = vEncSample->Release();
697 ASSERT_EQ(AV_ERR_OK, ret);
698 }
699 else {
700 return;
701 }
702 }
703
704 /**
705 * @tc.number : VIDEO_ENCODE_STATE_2800
706 * @tc.name : create-configure-start-flush-reset-error
707 * @tc.desc : function test
708 */
709 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2800, TestSize.Level2)
710 {
711 if (cap != nullptr) {
712 int32_t ret = vEncSample->Start();
713 ASSERT_EQ(AV_ERR_OK, ret);
714 ret = vEncSample->Flush();
715 ASSERT_EQ(AV_ERR_OK, ret);
716 ret = vEncSample->Reset();
717 ASSERT_EQ(AV_ERR_OK, ret);
718 ret = vEncSample->Start();
719 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
720 ret = vEncSample->Stop();
721 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
722 ret = vEncSample->Flush();
723 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
724 ret = vEncSample->SetVideoEncoderCallback();
725 ASSERT_EQ(AV_ERR_OK, ret);
726 }
727 else {
728 return;
729 }
730 }
731
732 /**
733 * @tc.number : VIDEO_ENCODE_STATE_2900
734 * @tc.name : create-configure-start-reset-configure
735 * @tc.desc : function test
736 */
737 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_2900, TestSize.Level2)
738 {
739 if (cap != nullptr) {
740 int32_t ret = vEncSample->Start();
741 ASSERT_EQ(AV_ERR_OK, ret);
742 ret = vEncSample->Reset();
743 ASSERT_EQ(AV_ERR_OK, ret);
744 ret = vEncSample->ConfigureVideoEncoder();
745 ASSERT_EQ(AV_ERR_OK, ret);
746 }
747 else {
748 return;
749 }
750 }
751
752 /**
753 * @tc.number : VIDEO_ENCODE_STATE_3000
754 * @tc.name : create-configure-start-reset-release
755 * @tc.desc : function test
756 */
757 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3000, TestSize.Level2)
758 {
759 if (cap != nullptr) {
760 int32_t ret = vEncSample->Start();
761 ASSERT_EQ(AV_ERR_OK, ret);
762 ret = vEncSample->Reset();
763 ASSERT_EQ(AV_ERR_OK, ret);
764 ret = vEncSample->Release();
765 ASSERT_EQ(AV_ERR_OK, ret);
766 }
767 else {
768 return;
769 }
770 }
771
772 /**
773 * @tc.number : VIDEO_ENCODE_STATE_3100
774 * @tc.name : create-configure-start-reset-error
775 * @tc.desc : function test
776 */
777 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3100, TestSize.Level2)
778 {
779 if (cap != nullptr) {
780 int32_t ret = vEncSample->Start();
781 ASSERT_EQ(AV_ERR_OK, ret);
782 ret = vEncSample->Reset();
783 ASSERT_EQ(AV_ERR_OK, ret);
784 ret = vEncSample->Start();
785 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
786 ret = vEncSample->Stop();
787 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
788 ret = vEncSample->Flush();
789 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
790 ret = vEncSample->SetVideoEncoderCallback();
791 ASSERT_EQ(AV_ERR_OK, ret);
792 }
793 else {
794 return;
795 }
796 }
797
798 /**
799 * @tc.number : VIDEO_ENCODE_STATE_3200
800 * @tc.name : create-configure-start-error
801 * @tc.desc : function test
802 */
803 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3200, TestSize.Level2)
804 {
805 if (cap != nullptr) {
806 int32_t ret = vEncSample->Start();
807 ASSERT_EQ(AV_ERR_OK, ret);
808 ret = vEncSample->ConfigureVideoEncoder();
809 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
810 ret = vEncSample->SetVideoEncoderCallback();
811 ASSERT_EQ(AV_ERR_OK, ret);
812 ret = vEncSample->Release();
813 ASSERT_EQ(AV_ERR_OK, ret);
814 }
815 else {
816 return;
817 }
818 }
819
820 /**
821 * @tc.number : VIDEO_ENCODE_STATE_3300
822 * @tc.name : create-configure-reset-configure
823 * @tc.desc : function test
824 */
825 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3300, TestSize.Level2)
826 {
827 if (cap != nullptr) {
828 int32_t ret = vEncSample->Reset();
829 ASSERT_EQ(AV_ERR_OK, ret);
830 ret = vEncSample->ConfigureVideoEncoder();
831 ASSERT_EQ(AV_ERR_OK, ret);
832 }
833 else {
834 return;
835 }
836 }
837
838 /**
839 * @tc.number : VIDEO_ENCODE_STATE_3400
840 * @tc.name : create-configure-release
841 * @tc.desc : function test
842 */
843 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3400, TestSize.Level2)
844 {
845 if (cap != nullptr) {
846 int32_t ret = vEncSample->Release();
847 ASSERT_EQ(AV_ERR_OK, ret);
848 }
849 else {
850 return;
851 }
852 }
853
854 /**
855 * @tc.number : VIDEO_ENCODE_STATE_3500
856 * @tc.name : Flush in surf encode callback function
857 * @tc.desc : function test
858 */
859 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3500, TestSize.Level1)
860 {
861 if (cap != nullptr) {
862 vEncSample->outputCallbackFlush = true;
863 vEncSample->SURF_INPUT = true;
864 int32_t ret = vEncSample->StartVideoEncoder();
865 ASSERT_EQ(AV_ERR_OK, ret);
866 vEncSample->WaitForEOS();
867 }
868 else {
869 return;
870 }
871 }
872
873 /**
874 * @tc.number : VIDEO_ENCODE_STATE_3600
875 * @tc.name : Stop in surf encode callback function
876 * @tc.desc : function test
877 */
878 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3600, TestSize.Level1)
879 {
880 if (cap != nullptr) {
881 vEncSample->outputCallbackStop = true;
882 vEncSample->SURF_INPUT = true;
883 int32_t ret = vEncSample->StartVideoEncoder();
884 ASSERT_EQ(AV_ERR_OK, ret);
885 vEncSample->WaitForEOS();
886 }
887 else {
888 return;
889 }
890 }
891
892 /**
893 * @tc.number : VIDEO_ENCODE_STATE_3700
894 * @tc.name : Flush or stop in buffer encode callback function
895 * @tc.desc : function test
896 */
897 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3700, TestSize.Level1)
898 {
899 if (cap != nullptr) {
900 vEncSample->inputCallbackFlush = true;
901 int32_t ret = vEncSample->StartVideoEncoder();
902 ASSERT_EQ(AV_ERR_OK, ret);
903 vEncSample->WaitForEOS();
904 }
905 else {
906 return;
907 }
908 }
909
910 /**
911 * @tc.number : VIDEO_ENCODE_STATE_3800
912 * @tc.name : Flush or stop in buffer encode callback function
913 * @tc.desc : function test
914 */
915 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3800, TestSize.Level1)
916 {
917 if (cap != nullptr) {
918 vEncSample->inputCallbackStop = true;
919 int32_t ret = vEncSample->StartVideoEncoder();
920 ASSERT_EQ(AV_ERR_OK, ret);
921 vEncSample->WaitForEOS();
922 }
923 else {
924 return;
925 }
926 }
927
928 /**
929 * @tc.number : VIDEO_ENCODE_STATE_3900
930 * @tc.name : Flush or stop in buffer encode callback function
931 * @tc.desc : function test
932 */
933 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_3900, TestSize.Level1)
934 {
935 if (cap != nullptr) {
936 vEncSample->outputCallbackFlush = true;
937 int32_t ret = vEncSample->StartVideoEncoder();
938 ASSERT_EQ(AV_ERR_OK, ret);
939 vEncSample->WaitForEOS();
940 }
941 else {
942 return;
943 }
944 }
945
946 /**
947 * @tc.number : VIDEO_ENCODE_STATE_4000
948 * @tc.name : Flush or stop in buffer encode callback function
949 * @tc.desc : function test
950 */
951 HWTEST_F(HwEncStateNdkTest, VIDEO_ENCODE_STATE_4000, TestSize.Level1)
952 {
953 if (cap != nullptr) {
954 vEncSample->outputCallbackStop = true;
955 int32_t ret = vEncSample->StartVideoEncoder();
956 ASSERT_EQ(AV_ERR_OK, ret);
957 vEncSample->WaitForEOS();
958 }
959 else {
960 return;
961 }
962 }
963 } // namespace