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