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 #include "native_avcapability.h"
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
49 namespace {
50 static OH_AVCapability *cap_mpeg2 = nullptr;
51 static string g_codecNameMpeg2 = "";
52 } // namespace
53
SetUpTestCase(void)54 void Mpeg2SwdecStateNdkTest::SetUpTestCase(void)
55 {
56 cap_mpeg2 = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_MPEG2, false, SOFTWARE);
57 g_codecNameMpeg2 = OH_AVCapability_GetName(cap_mpeg2);
58 cout << "g_codecNameMpeg2: " << g_codecNameMpeg2 << endl;
59 }
TearDownTestCase(void)60 void Mpeg2SwdecStateNdkTest::TearDownTestCase(void) {}
61 VDecNdkSample *vDecSample = NULL;
62
SetUp(void)63 void Mpeg2SwdecStateNdkTest::SetUp(void)
64 {
65 if (cap_mpeg2 != nullptr) {
66 vDecSample = new VDecNdkSample();
67 string codeName = "OH.Media.Codec.Decoder.Video.MPEG2";
68 int32_t ret = vDecSample->CreateVideoDecoder(codeName);
69 ASSERT_EQ(AV_ERR_OK, ret);
70 ret = vDecSample->SetVideoDecoderCallback();
71 ASSERT_EQ(AV_ERR_OK, ret);
72 ret = vDecSample->ConfigureVideoDecoder();
73 ASSERT_EQ(AV_ERR_OK, ret);
74 vDecSample->INP_DIR = "/data/test/media/422P@high_level_1920_1080_60.m2v";
75 }
76 }
77
TearDown(void)78 void Mpeg2SwdecStateNdkTest::TearDown(void)
79 {
80 vDecSample->Release();
81 delete vDecSample;
82 vDecSample = nullptr;
83 }
84 } // namespace Media
85 } // namespace OHOS
86
87 namespace {
88 /**
89 * @tc.number : VIDEO_SWDEC_STATE_0100
90 * @tc.name : create-configure-error
91 * @tc.desc : function test
92 */
93 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0100, TestSize.Level2)
94 {
95 if (cap_mpeg2 != nullptr) {
96 int32_t ret = vDecSample->Flush();
97 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
98 ret = vDecSample->SetVideoDecoderCallback();
99 ASSERT_EQ(AV_ERR_OK, ret);
100 }
101 }
102
103 /**
104 * @tc.number : VIDEO_SWDEC_STATE_0200
105 * @tc.name : create-configure-start-stop-start
106 * @tc.desc : function test
107 */
108 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0200, TestSize.Level2)
109 {
110 if (cap_mpeg2 != nullptr) {
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->Start();
116 ASSERT_EQ(AV_ERR_OK, ret);
117 }
118 }
119
120 /**
121 * @tc.number : VIDEO_SWDEC_STATE_0300
122 * @tc.name : create-configure-start-stop-release
123 * @tc.desc : function test
124 */
125 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0300, TestSize.Level2)
126 {
127 if (cap_mpeg2 != nullptr) {
128 int32_t ret = vDecSample->Start();
129 ASSERT_EQ(AV_ERR_OK, ret);
130 ret = vDecSample->Stop();
131 ASSERT_EQ(AV_ERR_OK, ret);
132 ret = vDecSample->Release();
133 ASSERT_EQ(AV_ERR_OK, ret);
134 }
135 }
136
137 /**
138 * @tc.number : VIDEO_SWDEC_STATE_0400
139 * @tc.name : create-configure-start-stop-reset
140 * @tc.desc : function test
141 */
142 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0400, TestSize.Level2)
143 {
144 if (cap_mpeg2 != nullptr) {
145 int32_t ret = vDecSample->Start();
146 ASSERT_EQ(AV_ERR_OK, ret);
147 ret = vDecSample->Stop();
148 ASSERT_EQ(AV_ERR_OK, ret);
149 ret = vDecSample->Reset();
150 ASSERT_EQ(AV_ERR_OK, ret);
151 }
152 }
153
154 /**
155 * @tc.number : VIDEO_SWDEC_STATE_0500
156 * @tc.name : create-configure-start-stop-error
157 * @tc.desc : function test
158 */
159 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0500, TestSize.Level2)
160 {
161 if (cap_mpeg2 != nullptr) {
162 int32_t ret = vDecSample->Start();
163 ASSERT_EQ(AV_ERR_OK, ret);
164 ret = vDecSample->Stop();
165 ASSERT_EQ(AV_ERR_OK, ret);
166 ret = vDecSample->Flush();
167 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
168 ret = vDecSample->SetVideoDecoderCallback();
169 ASSERT_EQ(AV_ERR_OK, ret);
170 }
171 }
172
173 /**
174 * @tc.number : VIDEO_SWDEC_STATE_0600
175 * @tc.name : create-configure-start-EOS-stop-start
176 * @tc.desc : function test
177 */
178 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0600, TestSize.Level2)
179 {
180 if (cap_mpeg2 != nullptr) {
181 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
182 int32_t ret = vDecSample->StartVideoDecoder();
183 ASSERT_EQ(AV_ERR_OK, ret);
184 vDecSample->WaitForEOS();
185 ASSERT_EQ(AV_ERR_OK, ret);
186 ASSERT_EQ(0, vDecSample->errCount);
187 ret = vDecSample->Stop();
188 ASSERT_EQ(AV_ERR_OK, ret);
189 ret = vDecSample->Start();
190 ASSERT_EQ(AV_ERR_OK, ret);
191 }
192 }
193
194 /**
195 * @tc.number : VIDEO_SWDEC_STATE_0700
196 * @tc.name : create-configure-start-EOS-stop-release
197 * @tc.desc : function test
198 */
199 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0700, TestSize.Level2)
200 {
201 if (cap_mpeg2 != nullptr) {
202 int32_t ret = vDecSample->StartVideoDecoder();
203 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
204 vDecSample->WaitForEOS();
205 ASSERT_EQ(AV_ERR_OK, ret);
206 ASSERT_EQ(0, vDecSample->errCount);
207 ret = vDecSample->Stop();
208 ASSERT_EQ(AV_ERR_OK, ret);
209 ret = vDecSample->Release();
210 ASSERT_EQ(AV_ERR_OK, ret);
211 }
212 }
213
214 /**
215 * @tc.number : VIDEO_SWDEC_STATE_0800
216 * @tc.name : create-configure-start-EOS-stop-reset
217 * @tc.desc : function test
218 */
219 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0800, TestSize.Level2)
220 {
221 if (cap_mpeg2 != nullptr) {
222 int32_t ret = vDecSample->StartVideoDecoder();
223 ASSERT_EQ(AV_ERR_OK, ret);
224 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
225 vDecSample->WaitForEOS();
226 ASSERT_EQ(AV_ERR_OK, ret);
227 ASSERT_EQ(0, vDecSample->errCount);
228 ret = vDecSample->Stop();
229 ASSERT_EQ(AV_ERR_OK, ret);
230 ret = vDecSample->Reset();
231 ASSERT_EQ(AV_ERR_OK, ret);
232 }
233 }
234
235 /**
236 * @tc.number : VIDEO_SWDEC_STATE_0900
237 * @tc.name : create-configure-start-EOS-flush
238 * @tc.desc : function test
239 */
240 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_0900, TestSize.Level2)
241 {
242 if (cap_mpeg2 != nullptr) {
243 int32_t ret = vDecSample->StartVideoDecoder();
244 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
245 vDecSample->WaitForEOS();
246 ASSERT_EQ(AV_ERR_OK, ret);
247 ASSERT_EQ(0, vDecSample->errCount);
248 ret = vDecSample->Flush();
249 ASSERT_EQ(AV_ERR_OK, ret);
250 }
251 }
252
253 /**
254 * @tc.number : VIDEO_SWDEC_STATE_1000
255 * @tc.name : create-configure-start-EOS-flush-start
256 * @tc.desc : function test
257 */
258 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1000, TestSize.Level2)
259 {
260 if (cap_mpeg2 != nullptr) {
261 int32_t ret = vDecSample->StartVideoDecoder();
262 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
263 vDecSample->WaitForEOS();
264 ASSERT_EQ(AV_ERR_OK, ret);
265 ASSERT_EQ(0, vDecSample->errCount);
266 ret = vDecSample->Flush();
267 ASSERT_EQ(AV_ERR_OK, ret);
268 ret = vDecSample->Start();
269 ASSERT_EQ(AV_ERR_OK, ret);
270 }
271 }
272
273 /**
274 * @tc.number : VIDEO_SWDEC_STATE_1100
275 * @tc.name : create-configure-start-EOS-flush-stop
276 * @tc.desc : function test
277 */
278 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1100, TestSize.Level2)
279 {
280 if (cap_mpeg2 != nullptr) {
281 int32_t ret = vDecSample->StartVideoDecoder();
282 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
283 vDecSample->WaitForEOS();
284 ASSERT_EQ(AV_ERR_OK, ret);
285 ASSERT_EQ(0, vDecSample->errCount);
286 ret = vDecSample->Flush();
287 ASSERT_EQ(AV_ERR_OK, ret);
288 ret = vDecSample->Stop();
289 ASSERT_EQ(AV_ERR_OK, ret);
290 }
291 }
292
293 /**
294 * @tc.number : VIDEO_SWDEC_STATE_1200
295 * @tc.name : create-configure-start-EOS-flush-reset
296 * @tc.desc : function test
297 */
298 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1200, TestSize.Level2)
299 {
300 if (cap_mpeg2 != nullptr) {
301 int32_t ret = vDecSample->StartVideoDecoder();
302 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
303 vDecSample->WaitForEOS();
304 ASSERT_EQ(AV_ERR_OK, ret);
305 ASSERT_EQ(0, vDecSample->errCount);
306 ret = vDecSample->Flush();
307 ASSERT_EQ(AV_ERR_OK, ret);
308 ret = vDecSample->Reset();
309 ASSERT_EQ(AV_ERR_OK, ret);
310 }
311 }
312
313 /**
314 * @tc.number : VIDEO_SWDEC_STATE_1300
315 * @tc.name : create-configure-start-EOS-flush-error
316 * @tc.desc : function test
317 */
318 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1300, TestSize.Level2)
319 {
320 if (cap_mpeg2 != nullptr) {
321 int32_t ret = vDecSample->StartVideoDecoder();
322 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
323 vDecSample->WaitForEOS();
324 ASSERT_EQ(AV_ERR_OK, ret);
325 ASSERT_EQ(0, vDecSample->errCount);
326 ret = vDecSample->Flush();
327 ASSERT_EQ(AV_ERR_OK, ret);
328 ret = vDecSample->Release();
329 ASSERT_EQ(AV_ERR_OK, ret);
330 ret = vDecSample->ConfigureVideoDecoder();
331 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
332 }
333 }
334
335 /**
336 * @tc.number : VIDEO_SWDEC_STATE_1400
337 * @tc.name : create-configure-start-EOS-reset-configure
338 * @tc.desc : function test
339 */
340 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1400, TestSize.Level2)
341 {
342 if (cap_mpeg2 != nullptr) {
343 int32_t ret = vDecSample->StartVideoDecoder();
344 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
345 vDecSample->WaitForEOS();
346 ASSERT_EQ(AV_ERR_OK, ret);
347 ASSERT_EQ(0, vDecSample->errCount);
348 ret = vDecSample->Reset();
349 ASSERT_EQ(AV_ERR_OK, ret);
350 ret = vDecSample->ConfigureVideoDecoder();
351 ASSERT_EQ(AV_ERR_OK, ret);
352 }
353 }
354
355 /**
356 * @tc.number : VIDEO_SWDEC_STATE_1500
357 * @tc.name : create-configure-start-EOS-reset-release
358 * @tc.desc : function test
359 */
360 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1500, TestSize.Level2)
361 {
362 if (cap_mpeg2 != nullptr) {
363 int32_t ret = vDecSample->StartVideoDecoder();
364 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
365 vDecSample->WaitForEOS();
366 ASSERT_EQ(AV_ERR_OK, ret);
367 ASSERT_EQ(0, vDecSample->errCount);
368 ret = vDecSample->Reset();
369 ASSERT_EQ(AV_ERR_OK, ret);
370 ret = vDecSample->Release();
371 ASSERT_EQ(AV_ERR_OK, ret);
372 }
373 }
374
375 /**
376 * @tc.number : VIDEO_SWDEC_STATE_1600
377 * @tc.name : create-configure-start-EOS-reset-error
378 * @tc.desc : function test
379 */
380 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1600, TestSize.Level2)
381 {
382 if (cap_mpeg2 != nullptr) {
383 int32_t ret = vDecSample->StartVideoDecoder();
384 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
385 vDecSample->WaitForEOS();
386 ASSERT_EQ(AV_ERR_OK, ret);
387 ASSERT_EQ(0, vDecSample->errCount);
388 ret = vDecSample->Reset();
389 ASSERT_EQ(AV_ERR_OK, ret);
390 ret = vDecSample->Start();
391 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
392 ret = vDecSample->Stop();
393 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
394 ret = vDecSample->Flush();
395 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
396 }
397 }
398
399 /**
400 * @tc.number : VIDEO_SWDEC_STATE_1700
401 * @tc.name : create-configure-start-flush-start-flush
402 * @tc.desc : function test
403 */
404 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1700, TestSize.Level2)
405 {
406 if (cap_mpeg2 != nullptr) {
407 int32_t ret = vDecSample->Start();
408 ASSERT_EQ(AV_ERR_OK, ret);
409 ret = vDecSample->Flush();
410 ASSERT_EQ(AV_ERR_OK, ret);
411 ret = vDecSample->Start();
412 ASSERT_EQ(AV_ERR_OK, ret);
413 ret = vDecSample->Flush();
414 ASSERT_EQ(AV_ERR_OK, ret);
415 }
416 }
417
418 /**
419 * @tc.number : VIDEO_SWDEC_STATE_1800
420 * @tc.name : create-configure-start-flush-start-eos
421 * @tc.desc : function test
422 */
423 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1800, TestSize.Level2)
424 {
425 if (cap_mpeg2 != nullptr) {
426 int32_t ret = vDecSample->Start();
427 ASSERT_EQ(AV_ERR_OK, ret);
428 ret = vDecSample->Flush();
429 ASSERT_EQ(AV_ERR_OK, ret);
430 ret = vDecSample->Start();
431 ASSERT_EQ(AV_ERR_OK, ret);
432 ret = vDecSample->state_EOS();
433 ASSERT_EQ(AV_ERR_OK, ret);
434 }
435 }
436
437 /**
438 * @tc.number : VIDEO_SWDEC_STATE_1900
439 * @tc.name : create-configure-start-flush-start-stop
440 * @tc.desc : function test
441 */
442 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_1900, TestSize.Level2)
443 {
444 if (cap_mpeg2 != nullptr) {
445 int32_t ret = vDecSample->Start();
446 ASSERT_EQ(AV_ERR_OK, ret);
447 ret = vDecSample->Flush();
448 ASSERT_EQ(AV_ERR_OK, ret);
449 ret = vDecSample->Start();
450 ASSERT_EQ(AV_ERR_OK, ret);
451 ret = vDecSample->Stop();
452 ASSERT_EQ(AV_ERR_OK, ret);
453 }
454 }
455
456 /**
457 * @tc.number : VIDEO_SWDEC_STATE_2000
458 * @tc.name : create-configure-start-flush-start-reset
459 * @tc.desc : function test
460 */
461 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2000, TestSize.Level2)
462 {
463 if (cap_mpeg2 != nullptr) {
464 int32_t ret = vDecSample->Start();
465 ASSERT_EQ(AV_ERR_OK, ret);
466 ret = vDecSample->Flush();
467 ASSERT_EQ(AV_ERR_OK, ret);
468 ret = vDecSample->Start();
469 ASSERT_EQ(AV_ERR_OK, ret);
470 ret = vDecSample->Reset();
471 ASSERT_EQ(AV_ERR_OK, ret);
472 }
473 }
474
475 /**
476 * @tc.number : VIDEO_SWDEC_STATE_2100
477 * @tc.name : create-configure-start-flush-start-error
478 * @tc.desc : function test
479 */
480 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2100, TestSize.Level2)
481 {
482 if (cap_mpeg2 != nullptr) {
483 int32_t ret = vDecSample->Start();
484 ASSERT_EQ(AV_ERR_OK, ret);
485 ret = vDecSample->Flush();
486 ASSERT_EQ(AV_ERR_OK, ret);
487 ret = vDecSample->Start();
488 ASSERT_EQ(AV_ERR_OK, ret);
489 ret = vDecSample->ConfigureVideoDecoder();
490 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
491 ret = vDecSample->SetVideoDecoderCallback();
492 ASSERT_EQ(AV_ERR_OK, ret);
493 ret = vDecSample->Release();
494 ASSERT_EQ(AV_ERR_OK, ret);
495 }
496 }
497
498 /**
499 * @tc.number : VIDEO_SWDEC_STATE_2200
500 * @tc.name : create-configure-start-flush-start
501 * @tc.desc : function test
502 */
503 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2200, TestSize.Level2)
504 {
505 if (cap_mpeg2 != nullptr) {
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->Start();
513 ASSERT_EQ(AV_ERR_OK, ret);
514 }
515 }
516
517 /**
518 * @tc.number : VIDEO_SWDEC_STATE_2300
519 * @tc.name : create-configure-start-flush-stop-start
520 * @tc.desc : function test
521 */
522 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2300, TestSize.Level2)
523 {
524 if (cap_mpeg2 != nullptr) {
525 int32_t ret = vDecSample->Start();
526 ASSERT_EQ(AV_ERR_OK, ret);
527 ret = vDecSample->Flush();
528 ASSERT_EQ(AV_ERR_OK, ret);
529 ret = vDecSample->Stop();
530 ASSERT_EQ(AV_ERR_OK, ret);
531 ret = vDecSample->Release();
532 ASSERT_EQ(AV_ERR_OK, ret);
533 }
534 }
535
536 /**
537 * @tc.number : VIDEO_SWDEC_STATE_2400
538 * @tc.name : create-configure-start-flush-stop-reset
539 * @tc.desc : function test
540 */
541 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2400, TestSize.Level2)
542 {
543 if (cap_mpeg2 != nullptr) {
544 int32_t ret = vDecSample->Start();
545 ASSERT_EQ(AV_ERR_OK, ret);
546 ret = vDecSample->Flush();
547 ASSERT_EQ(AV_ERR_OK, ret);
548 ret = vDecSample->Stop();
549 ASSERT_EQ(AV_ERR_OK, ret);
550 ret = vDecSample->Reset();
551 ASSERT_EQ(AV_ERR_OK, ret);
552 }
553 }
554
555 /**
556 * @tc.number : VIDEO_SWDEC_STATE_2500
557 * @tc.name : create-configure-start-flush-stop-error
558 * @tc.desc : function test
559 */
560 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2500, TestSize.Level2)
561 {
562 if (cap_mpeg2 != nullptr) {
563 int32_t ret = vDecSample->Start();
564 ASSERT_EQ(AV_ERR_OK, ret);
565 ret = vDecSample->Flush();
566 ASSERT_EQ(AV_ERR_OK, ret);
567 ret = vDecSample->Stop();
568 ASSERT_EQ(AV_ERR_OK, ret);
569 ret = vDecSample->Flush();
570 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
571 ret = vDecSample->SetVideoDecoderCallback();
572 ASSERT_EQ(AV_ERR_OK, ret);
573 }
574 }
575
576 /**
577 * @tc.number : VIDEO_SWDEC_STATE_2600
578 * @tc.name : create-configure-start-flush-reset-configure
579 * @tc.desc : function test
580 */
581 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2600, TestSize.Level2)
582 {
583 if (cap_mpeg2 != nullptr) {
584 int32_t ret = vDecSample->Start();
585 ASSERT_EQ(AV_ERR_OK, ret);
586 ret = vDecSample->Flush();
587 ASSERT_EQ(AV_ERR_OK, ret);
588 ret = vDecSample->Reset();
589 ASSERT_EQ(AV_ERR_OK, ret);
590 ret = vDecSample->ConfigureVideoDecoder();
591 ASSERT_EQ(AV_ERR_OK, ret);
592 }
593 }
594
595 /**
596 * @tc.number : VIDEO_SWDEC_STATE_2700
597 * @tc.name : create-configure-start-flush-reset-release
598 * @tc.desc : function test
599 */
600 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2700, TestSize.Level2)
601 {
602 if (cap_mpeg2 != nullptr) {
603 int32_t ret = vDecSample->Start();
604 ASSERT_EQ(AV_ERR_OK, ret);
605 ret = vDecSample->Flush();
606 ASSERT_EQ(AV_ERR_OK, ret);
607 ret = vDecSample->Reset();
608 ASSERT_EQ(AV_ERR_OK, ret);
609 ret = vDecSample->Release();
610 ASSERT_EQ(AV_ERR_OK, ret);
611 }
612 }
613
614 /**
615 * @tc.number : VIDEO_SWDEC_STATE_2800
616 * @tc.name : create-configure-start-flush-reset-error
617 * @tc.desc : function test
618 */
619 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2800, TestSize.Level2)
620 {
621 if (cap_mpeg2 != nullptr) {
622 int32_t ret = vDecSample->Start();
623 ASSERT_EQ(AV_ERR_OK, ret);
624 ret = vDecSample->Flush();
625 ASSERT_EQ(AV_ERR_OK, ret);
626 ret = vDecSample->Reset();
627 ASSERT_EQ(AV_ERR_OK, ret);
628 ret = vDecSample->Start();
629 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
630 ret = vDecSample->Stop();
631 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
632 ret = vDecSample->Flush();
633 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
634 ret = vDecSample->SetVideoDecoderCallback();
635 ASSERT_EQ(AV_ERR_OK, ret);
636 }
637 }
638
639 /**
640 * @tc.number : VIDEO_SWDEC_STATE_2900
641 * @tc.name : create-configure-start-reset-configure
642 * @tc.desc : function test
643 */
644 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_2900, TestSize.Level2)
645 {
646 if (cap_mpeg2 != nullptr) {
647 int32_t ret = vDecSample->Start();
648 ASSERT_EQ(AV_ERR_OK, ret);
649 ret = vDecSample->Reset();
650 ASSERT_EQ(AV_ERR_OK, ret);
651 ret = vDecSample->ConfigureVideoDecoder();
652 ASSERT_EQ(AV_ERR_OK, ret);
653 }
654 }
655
656 /**
657 * @tc.number : VIDEO_SWDEC_STATE_3000
658 * @tc.name : create-configure-start-reset-release
659 * @tc.desc : function test
660 */
661 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3000, TestSize.Level2)
662 {
663 if (cap_mpeg2 != nullptr) {
664 int32_t ret = vDecSample->Start();
665 ASSERT_EQ(AV_ERR_OK, ret);
666 ret = vDecSample->Reset();
667 ASSERT_EQ(AV_ERR_OK, ret);
668 ret = vDecSample->Release();
669 ASSERT_EQ(AV_ERR_OK, ret);
670 }
671 }
672
673 /**
674 * @tc.number : VIDEO_SWDEC_STATE_3100
675 * @tc.name : create-configure-start-reset-error
676 * @tc.desc : function test
677 */
678 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3100, TestSize.Level2)
679 {
680 if (cap_mpeg2 != nullptr) {
681 int32_t ret = vDecSample->Start();
682 ASSERT_EQ(AV_ERR_OK, ret);
683 ret = vDecSample->Reset();
684 ASSERT_EQ(AV_ERR_OK, ret);
685 ret = vDecSample->Start();
686 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
687 ret = vDecSample->Stop();
688 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
689 ret = vDecSample->Flush();
690 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
691 ret = vDecSample->SetVideoDecoderCallback();
692 ASSERT_EQ(AV_ERR_OK, ret);
693 }
694 }
695
696 /**
697 * @tc.number : VIDEO_SWDEC_STATE_3200
698 * @tc.name : create-configure-start-error
699 * @tc.desc : function test
700 */
701 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3200, TestSize.Level2)
702 {
703 if (cap_mpeg2 != nullptr) {
704 int32_t ret = vDecSample->Start();
705 ASSERT_EQ(AV_ERR_OK, ret);
706 ret = vDecSample->ConfigureVideoDecoder();
707 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
708 ret = vDecSample->SetVideoDecoderCallback();
709 ASSERT_EQ(AV_ERR_OK, ret);
710 ret = vDecSample->Release();
711 ASSERT_EQ(AV_ERR_OK, ret);
712 }
713 }
714
715 /**
716 * @tc.number : VIDEO_SWDEC_STATE_3300
717 * @tc.name : create-configure-reset-configure
718 * @tc.desc : function test
719 */
720 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3300, TestSize.Level2)
721 {
722 if (cap_mpeg2 != nullptr) {
723 int32_t ret = vDecSample->Reset();
724 ASSERT_EQ(AV_ERR_OK, ret);
725 ret = vDecSample->ConfigureVideoDecoder();
726 ASSERT_EQ(AV_ERR_OK, ret);
727 }
728 }
729
730 /**
731 * @tc.number : VIDEO_SWDEC_STATE_3400
732 * @tc.name : create-configure-release
733 * @tc.desc : function test
734 */
735 HWTEST_F(Mpeg2SwdecStateNdkTest, VIDEO_SWDEC_STATE_3400, TestSize.Level2)
736 {
737 if (cap_mpeg2 != nullptr) {
738 int32_t ret = vDecSample->Release();
739 ASSERT_EQ(AV_ERR_OK, ret);
740 }
741 }
742 } // namespace