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