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