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