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 "videodec_sample.h"
27 using namespace std;
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace testing::ext;
31 namespace OHOS {
32 namespace Media {
33 class Mpeg2SwdecStateNdkTest : public testing::Test {
34 public:
35 // SetUpTestCase: Called before all test cases
36 static void SetUpTestCase(void);
37 // TearDownTestCase: Called after all test case
38 static void TearDownTestCase(void);
39 // SetUp: Called before each test cases
40 void SetUp(void);
41 // TearDown: Called after each test cases
42 void TearDown(void);
43
44 protected:
45 const ::testing::TestInfo *testInfo_ = nullptr;
46 bool createCodecSuccess_ = false;
47 };
48
SetUpTestCase(void)49 void Mpeg2SwdecStateNdkTest::SetUpTestCase(void) {}
TearDownTestCase(void)50 void Mpeg2SwdecStateNdkTest::TearDownTestCase(void) {}
51 VDecNdkSample *vDecSample = NULL;
52
SetUp(void)53 void Mpeg2SwdecStateNdkTest::SetUp(void)
54 {
55 vDecSample = new VDecNdkSample();
56 string codeName = "OH.Media.Codec.Decoder.Video.MPEG2";
57 int32_t ret = vDecSample->CreateVideoDecoder(codeName);
58 ASSERT_EQ(AV_ERR_OK, ret);
59 ret = vDecSample->SetVideoDecoderCallback();
60 ASSERT_EQ(AV_ERR_OK, ret);
61 ret = vDecSample->ConfigureVideoDecoder();
62 ASSERT_EQ(AV_ERR_OK, ret);
63 vDecSample->INP_DIR = "/data/test/media/422P@high_level_1920_1080_60.m2v";
64 }
65
TearDown(void)66 void Mpeg2SwdecStateNdkTest::TearDown(void)
67 {
68 vDecSample->Release();
69 delete vDecSample;
70 vDecSample = nullptr;
71 }
72 } // namespace Media
73 } // namespace OHOS
74
75 namespace {
76 /**
77 * @tc.number : VIDEO_SWDEC_STATE_0100
78 * @tc.name : create-configure-error
79 * @tc.desc : function test
80 */
81 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0100, TestSize.Level2)
82 {
83 int32_t ret = vDecSample->Flush();
84 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
85 ret = vDecSample->SetVideoDecoderCallback();
86 ASSERT_EQ(AV_ERR_OK, ret);
87 }
88
89 /**
90 * @tc.number : VIDEO_SWDEC_STATE_0200
91 * @tc.name : create-configure-start-stop-start
92 * @tc.desc : function test
93 */
94 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0200, TestSize.Level2)
95 {
96 int32_t ret = vDecSample->Start();
97 ASSERT_EQ(AV_ERR_OK, ret);
98 ret = vDecSample->Stop();
99 ASSERT_EQ(AV_ERR_OK, ret);
100 ret = vDecSample->Start();
101 ASSERT_EQ(AV_ERR_OK, ret);
102 }
103
104 /**
105 * @tc.number : VIDEO_SWDEC_STATE_0300
106 * @tc.name : create-configure-start-stop-release
107 * @tc.desc : function test
108 */
109 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0300, TestSize.Level2)
110 {
111 int32_t ret = vDecSample->Start();
112 ASSERT_EQ(AV_ERR_OK, ret);
113 ret = vDecSample->Stop();
114 ASSERT_EQ(AV_ERR_OK, ret);
115 ret = vDecSample->Release();
116 ASSERT_EQ(AV_ERR_OK, ret);
117 }
118
119 /**
120 * @tc.number : VIDEO_SWDEC_STATE_0400
121 * @tc.name : create-configure-start-stop-reset
122 * @tc.desc : function test
123 */
124 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0400, TestSize.Level2)
125 {
126 int32_t ret = vDecSample->Start();
127 ASSERT_EQ(AV_ERR_OK, ret);
128 ret = vDecSample->Stop();
129 ASSERT_EQ(AV_ERR_OK, ret);
130 ret = vDecSample->Reset();
131 ASSERT_EQ(AV_ERR_OK, ret);
132 }
133
134 /**
135 * @tc.number : VIDEO_SWDEC_STATE_0500
136 * @tc.name : create-configure-start-stop-error
137 * @tc.desc : function test
138 */
139 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0500, TestSize.Level2)
140 {
141 int32_t ret = vDecSample->Start();
142 ASSERT_EQ(AV_ERR_OK, ret);
143 ret = vDecSample->Stop();
144 ASSERT_EQ(AV_ERR_OK, ret);
145 ret = vDecSample->Flush();
146 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
147 ret = vDecSample->SetVideoDecoderCallback();
148 ASSERT_EQ(AV_ERR_OK, ret);
149 }
150
151 /**
152 * @tc.number : VIDEO_SWDEC_STATE_0600
153 * @tc.name : create-configure-start-EOS-stop-start
154 * @tc.desc : function test
155 */
156 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0600, TestSize.Level2)
157 {
158 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
159 int32_t ret = vDecSample->StartVideoDecoder();
160 ASSERT_EQ(AV_ERR_OK, ret);
161 vDecSample->WaitForEOS();
162 ASSERT_EQ(AV_ERR_OK, ret);
163 ASSERT_EQ(0, vDecSample->errCount);
164 ret = vDecSample->Stop();
165 ASSERT_EQ(AV_ERR_OK, ret);
166 ret = vDecSample->Start();
167 ASSERT_EQ(AV_ERR_OK, ret);
168 }
169
170 /**
171 * @tc.number : VIDEO_SWDEC_STATE_0700
172 * @tc.name : create-configure-start-EOS-stop-release
173 * @tc.desc : function test
174 */
175 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0700, TestSize.Level2)
176 {
177 int32_t ret = vDecSample->StartVideoDecoder();
178 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
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->Release();
185 ASSERT_EQ(AV_ERR_OK, ret);
186 }
187
188 /**
189 * @tc.number : VIDEO_SWDEC_STATE_0800
190 * @tc.name : create-configure-start-EOS-stop-reset
191 * @tc.desc : function test
192 */
193 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0800, TestSize.Level2)
194 {
195 int32_t ret = vDecSample->StartVideoDecoder();
196 ASSERT_EQ(AV_ERR_OK, ret);
197 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
198 vDecSample->WaitForEOS();
199 ASSERT_EQ(AV_ERR_OK, ret);
200 ASSERT_EQ(0, vDecSample->errCount);
201 ret = vDecSample->Stop();
202 ASSERT_EQ(AV_ERR_OK, ret);
203 ret = vDecSample->Reset();
204 ASSERT_EQ(AV_ERR_OK, ret);
205 }
206
207 /**
208 * @tc.number : VIDEO_SWDEC_STATE_0900
209 * @tc.name : create-configure-start-EOS-flush
210 * @tc.desc : function test
211 */
212 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0900, TestSize.Level2)
213 {
214 int32_t ret = vDecSample->StartVideoDecoder();
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->Flush();
220 ASSERT_EQ(AV_ERR_OK, ret);
221 }
222
223 /**
224 * @tc.number : VIDEO_SWDEC_STATE_1000
225 * @tc.name : create-configure-start-EOS-flush-start
226 * @tc.desc : function test
227 */
228 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1000, TestSize.Level2)
229 {
230 int32_t ret = vDecSample->StartVideoDecoder();
231 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
232 vDecSample->WaitForEOS();
233 ASSERT_EQ(AV_ERR_OK, ret);
234 ASSERT_EQ(0, vDecSample->errCount);
235 ret = vDecSample->Flush();
236 ASSERT_EQ(AV_ERR_OK, ret);
237 ret = vDecSample->Start();
238 ASSERT_EQ(AV_ERR_OK, ret);
239 }
240
241 /**
242 * @tc.number : VIDEO_SWDEC_STATE_1100
243 * @tc.name : create-configure-start-EOS-flush-stop
244 * @tc.desc : function test
245 */
246 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1100, 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->Stop();
256 ASSERT_EQ(AV_ERR_OK, ret);
257 }
258
259 /**
260 * @tc.number : VIDEO_SWDEC_STATE_1200
261 * @tc.name : create-configure-start-EOS-flush-reset
262 * @tc.desc : function test
263 */
264 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1200, 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->Reset();
274 ASSERT_EQ(AV_ERR_OK, ret);
275 }
276
277 /**
278 * @tc.number : VIDEO_SWDEC_STATE_1300
279 * @tc.name : create-configure-start-EOS-flush-error
280 * @tc.desc : function test
281 */
282 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1300, 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->Release();
292 ASSERT_EQ(AV_ERR_OK, ret);
293 ret = vDecSample->ConfigureVideoDecoder();
294 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
295 }
296
297 /**
298 * @tc.number : VIDEO_SWDEC_STATE_1400
299 * @tc.name : create-configure-start-EOS-reset-configure
300 * @tc.desc : function test
301 */
302 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1400, TestSize.Level2)
303 {
304 int32_t ret = vDecSample->StartVideoDecoder();
305 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
306 vDecSample->WaitForEOS();
307 ASSERT_EQ(AV_ERR_OK, ret);
308 ASSERT_EQ(0, vDecSample->errCount);
309 ret = vDecSample->Reset();
310 ASSERT_EQ(AV_ERR_OK, ret);
311 ret = vDecSample->ConfigureVideoDecoder();
312 ASSERT_EQ(AV_ERR_OK, ret);
313 }
314
315 /**
316 * @tc.number : VIDEO_SWDEC_STATE_1500
317 * @tc.name : create-configure-start-EOS-reset-release
318 * @tc.desc : function test
319 */
320 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1500, 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->Release();
330 ASSERT_EQ(AV_ERR_OK, ret);
331 }
332
333 /**
334 * @tc.number : VIDEO_SWDEC_STATE_1600
335 * @tc.name : create-configure-start-EOS-reset-error
336 * @tc.desc : function test
337 */
338 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1600, 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->Start();
348 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
349 ret = vDecSample->Stop();
350 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
351 ret = vDecSample->Flush();
352 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
353 }
354
355 /**
356 * @tc.number : VIDEO_SWDEC_STATE_1700
357 * @tc.name : create-configure-start-flush-start-flush
358 * @tc.desc : function test
359 */
360 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1700, TestSize.Level2)
361 {
362 int32_t ret = vDecSample->Start();
363 ASSERT_EQ(AV_ERR_OK, ret);
364 ret = vDecSample->Flush();
365 ASSERT_EQ(AV_ERR_OK, ret);
366 ret = vDecSample->Start();
367 ASSERT_EQ(AV_ERR_OK, ret);
368 ret = vDecSample->Flush();
369 ASSERT_EQ(AV_ERR_OK, ret);
370 }
371
372 /**
373 * @tc.number : VIDEO_SWDEC_STATE_1800
374 * @tc.name : create-configure-start-flush-start-eos
375 * @tc.desc : function test
376 */
377 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1800, TestSize.Level2)
378 {
379 int32_t ret = vDecSample->Start();
380 ASSERT_EQ(AV_ERR_OK, ret);
381 ret = vDecSample->Flush();
382 ASSERT_EQ(AV_ERR_OK, ret);
383 ret = vDecSample->Start();
384 ASSERT_EQ(AV_ERR_OK, ret);
385 ret = vDecSample->state_EOS();
386 ASSERT_EQ(AV_ERR_OK, ret);
387 }
388
389 /**
390 * @tc.number : VIDEO_SWDEC_STATE_1900
391 * @tc.name : create-configure-start-flush-start-stop
392 * @tc.desc : function test
393 */
394 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1900, TestSize.Level2)
395 {
396 int32_t ret = vDecSample->Start();
397 ASSERT_EQ(AV_ERR_OK, ret);
398 ret = vDecSample->Flush();
399 ASSERT_EQ(AV_ERR_OK, ret);
400 ret = vDecSample->Start();
401 ASSERT_EQ(AV_ERR_OK, ret);
402 ret = vDecSample->Stop();
403 ASSERT_EQ(AV_ERR_OK, ret);
404 }
405
406 /**
407 * @tc.number : VIDEO_SWDEC_STATE_2000
408 * @tc.name : create-configure-start-flush-start-reset
409 * @tc.desc : function test
410 */
411 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2000, TestSize.Level2)
412 {
413 int32_t ret = vDecSample->Start();
414 ASSERT_EQ(AV_ERR_OK, ret);
415 ret = vDecSample->Flush();
416 ASSERT_EQ(AV_ERR_OK, ret);
417 ret = vDecSample->Start();
418 ASSERT_EQ(AV_ERR_OK, ret);
419 ret = vDecSample->Reset();
420 ASSERT_EQ(AV_ERR_OK, ret);
421 }
422
423 /**
424 * @tc.number : VIDEO_SWDEC_STATE_2100
425 * @tc.name : create-configure-start-flush-start-error
426 * @tc.desc : function test
427 */
428 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2100, TestSize.Level2)
429 {
430 int32_t ret = vDecSample->Start();
431 ASSERT_EQ(AV_ERR_OK, ret);
432 ret = vDecSample->Flush();
433 ASSERT_EQ(AV_ERR_OK, ret);
434 ret = vDecSample->Start();
435 ASSERT_EQ(AV_ERR_OK, ret);
436 ret = vDecSample->ConfigureVideoDecoder();
437 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
438 ret = vDecSample->SetVideoDecoderCallback();
439 ASSERT_EQ(AV_ERR_OK, ret);
440 ret = vDecSample->Release();
441 ASSERT_EQ(AV_ERR_OK, ret);
442 }
443
444 /**
445 * @tc.number : VIDEO_SWDEC_STATE_2200
446 * @tc.name : create-configure-start-flush-start
447 * @tc.desc : function test
448 */
449 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2200, TestSize.Level2)
450 {
451 int32_t ret = vDecSample->Start();
452 ASSERT_EQ(AV_ERR_OK, ret);
453 ret = vDecSample->Flush();
454 ASSERT_EQ(AV_ERR_OK, ret);
455 ret = vDecSample->Stop();
456 ASSERT_EQ(AV_ERR_OK, ret);
457 ret = vDecSample->Start();
458 ASSERT_EQ(AV_ERR_OK, ret);
459 }
460
461 /**
462 * @tc.number : VIDEO_SWDEC_STATE_2300
463 * @tc.name : create-configure-start-flush-stop-start
464 * @tc.desc : function test
465 */
466 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2300, TestSize.Level2)
467 {
468 int32_t ret = vDecSample->Start();
469 ASSERT_EQ(AV_ERR_OK, ret);
470 ret = vDecSample->Flush();
471 ASSERT_EQ(AV_ERR_OK, ret);
472 ret = vDecSample->Stop();
473 ASSERT_EQ(AV_ERR_OK, ret);
474 ret = vDecSample->Release();
475 ASSERT_EQ(AV_ERR_OK, ret);
476 }
477
478 /**
479 * @tc.number : VIDEO_SWDEC_STATE_2400
480 * @tc.name : create-configure-start-flush-stop-reset
481 * @tc.desc : function test
482 */
483 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2400, TestSize.Level2)
484 {
485 int32_t ret = vDecSample->Start();
486 ASSERT_EQ(AV_ERR_OK, ret);
487 ret = vDecSample->Flush();
488 ASSERT_EQ(AV_ERR_OK, ret);
489 ret = vDecSample->Stop();
490 ASSERT_EQ(AV_ERR_OK, ret);
491 ret = vDecSample->Reset();
492 ASSERT_EQ(AV_ERR_OK, ret);
493 }
494
495 /**
496 * @tc.number : VIDEO_SWDEC_STATE_2500
497 * @tc.name : create-configure-start-flush-stop-error
498 * @tc.desc : function test
499 */
500 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2500, TestSize.Level2)
501 {
502 int32_t ret = vDecSample->Start();
503 ASSERT_EQ(AV_ERR_OK, ret);
504 ret = vDecSample->Flush();
505 ASSERT_EQ(AV_ERR_OK, ret);
506 ret = vDecSample->Stop();
507 ASSERT_EQ(AV_ERR_OK, ret);
508 ret = vDecSample->Flush();
509 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
510 ret = vDecSample->SetVideoDecoderCallback();
511 ASSERT_EQ(AV_ERR_OK, ret);
512 }
513
514 /**
515 * @tc.number : VIDEO_SWDEC_STATE_2600
516 * @tc.name : create-configure-start-flush-reset-configure
517 * @tc.desc : function test
518 */
519 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2600, TestSize.Level2)
520 {
521 int32_t ret = vDecSample->Start();
522 ASSERT_EQ(AV_ERR_OK, ret);
523 ret = vDecSample->Flush();
524 ASSERT_EQ(AV_ERR_OK, ret);
525 ret = vDecSample->Reset();
526 ASSERT_EQ(AV_ERR_OK, ret);
527 ret = vDecSample->ConfigureVideoDecoder();
528 ASSERT_EQ(AV_ERR_OK, ret);
529 }
530
531 /**
532 * @tc.number : VIDEO_SWDEC_STATE_2700
533 * @tc.name : create-configure-start-flush-reset-release
534 * @tc.desc : function test
535 */
536 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2700, TestSize.Level2)
537 {
538 int32_t ret = vDecSample->Start();
539 ASSERT_EQ(AV_ERR_OK, ret);
540 ret = vDecSample->Flush();
541 ASSERT_EQ(AV_ERR_OK, ret);
542 ret = vDecSample->Reset();
543 ASSERT_EQ(AV_ERR_OK, ret);
544 ret = vDecSample->Release();
545 ASSERT_EQ(AV_ERR_OK, ret);
546 }
547
548 /**
549 * @tc.number : VIDEO_SWDEC_STATE_2800
550 * @tc.name : create-configure-start-flush-reset-error
551 * @tc.desc : function test
552 */
553 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2800, TestSize.Level2)
554 {
555 int32_t ret = vDecSample->Start();
556 ASSERT_EQ(AV_ERR_OK, ret);
557 ret = vDecSample->Flush();
558 ASSERT_EQ(AV_ERR_OK, ret);
559 ret = vDecSample->Reset();
560 ASSERT_EQ(AV_ERR_OK, ret);
561 ret = vDecSample->Start();
562 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
563 ret = vDecSample->Stop();
564 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
565 ret = vDecSample->Flush();
566 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
567 ret = vDecSample->SetVideoDecoderCallback();
568 ASSERT_EQ(AV_ERR_OK, ret);
569 }
570
571 /**
572 * @tc.number : VIDEO_SWDEC_STATE_2900
573 * @tc.name : create-configure-start-reset-configure
574 * @tc.desc : function test
575 */
576 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2900, TestSize.Level2)
577 {
578 int32_t ret = vDecSample->Start();
579 ASSERT_EQ(AV_ERR_OK, ret);
580 ret = vDecSample->Reset();
581 ASSERT_EQ(AV_ERR_OK, ret);
582 ret = vDecSample->ConfigureVideoDecoder();
583 ASSERT_EQ(AV_ERR_OK, ret);
584 }
585
586 /**
587 * @tc.number : VIDEO_SWDEC_STATE_3000
588 * @tc.name : create-configure-start-reset-release
589 * @tc.desc : function test
590 */
591 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3000, TestSize.Level2)
592 {
593 int32_t ret = vDecSample->Start();
594 ASSERT_EQ(AV_ERR_OK, ret);
595 ret = vDecSample->Reset();
596 ASSERT_EQ(AV_ERR_OK, ret);
597 ret = vDecSample->Release();
598 ASSERT_EQ(AV_ERR_OK, ret);
599 }
600
601 /**
602 * @tc.number : VIDEO_SWDEC_STATE_3100
603 * @tc.name : create-configure-start-reset-error
604 * @tc.desc : function test
605 */
606 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3100, TestSize.Level2)
607 {
608 int32_t ret = vDecSample->Start();
609 ASSERT_EQ(AV_ERR_OK, ret);
610 ret = vDecSample->Reset();
611 ASSERT_EQ(AV_ERR_OK, ret);
612 ret = vDecSample->Start();
613 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
614 ret = vDecSample->Stop();
615 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
616 ret = vDecSample->Flush();
617 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
618 ret = vDecSample->SetVideoDecoderCallback();
619 ASSERT_EQ(AV_ERR_OK, ret);
620 }
621
622 /**
623 * @tc.number : VIDEO_SWDEC_STATE_3200
624 * @tc.name : create-configure-start-error
625 * @tc.desc : function test
626 */
627 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3200, TestSize.Level2)
628 {
629 int32_t ret = vDecSample->Start();
630 ASSERT_EQ(AV_ERR_OK, ret);
631 ret = vDecSample->ConfigureVideoDecoder();
632 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
633 ret = vDecSample->SetVideoDecoderCallback();
634 ASSERT_EQ(AV_ERR_OK, ret);
635 ret = vDecSample->Release();
636 ASSERT_EQ(AV_ERR_OK, ret);
637 }
638
639 /**
640 * @tc.number : VIDEO_SWDEC_STATE_3300
641 * @tc.name : create-configure-reset-configure
642 * @tc.desc : function test
643 */
644 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3300, TestSize.Level2)
645 {
646 int32_t ret = vDecSample->Reset();
647 ASSERT_EQ(AV_ERR_OK, ret);
648 ret = vDecSample->ConfigureVideoDecoder();
649 ASSERT_EQ(AV_ERR_OK, ret);
650 }
651
652 /**
653 * @tc.number : VIDEO_SWDEC_STATE_3400
654 * @tc.name : create-configure-release
655 * @tc.desc : function test
656 */
657 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3400, TestSize.Level2)
658 {
659 int32_t ret = vDecSample->Release();
660 ASSERT_EQ(AV_ERR_OK, ret);
661 }
662 } // namespace