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