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_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 SwdecStateNdkTest : 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 SwdecStateNdkTest::SetUpTestCase(void) {}
TearDownTestCase(void)50 void SwdecStateNdkTest::TearDownTestCase(void) {}
51 VDecNdkSample *vDecSample = NULL;
52
SetUp(void)53 void SwdecStateNdkTest::SetUp(void)
54 {
55 vDecSample = new VDecNdkSample();
56 string codeName = "OH.Media.Codec.Decoder.Video.AVC";
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/1920_1080_10_30Mb.h264";
64 }
65
TearDown(void)66 void SwdecStateNdkTest::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 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0100, TestSize.Level2)81 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0100, TestSize.Level2)
82 {
83 int32_t ret = vDecSample->Stop();
84 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
85 ret = vDecSample->Flush();
86 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
87 ret = vDecSample->SetVideoDecoderCallback();
88 ASSERT_EQ(AV_ERR_OK, ret);
89 }
90
91 /**
92 * @tc.number : VIDEO_SWDEC_STATE_0200
93 * @tc.name : create-configure-start-stop-start
94 * @tc.desc : function test
95 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0200, TestSize.Level2)96 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0200, TestSize.Level2)
97 {
98 int32_t ret = vDecSample->Start();
99 ASSERT_EQ(AV_ERR_OK, ret);
100 ret = vDecSample->Stop();
101 ASSERT_EQ(AV_ERR_OK, ret);
102 ret = vDecSample->Start();
103 ASSERT_EQ(AV_ERR_OK, ret);
104 }
105
106 /**
107 * @tc.number : VIDEO_SWDEC_STATE_0300
108 * @tc.name : create-configure-start-stop-release
109 * @tc.desc : function test
110 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0300, TestSize.Level2)111 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0300, TestSize.Level2)
112 {
113 int32_t ret = vDecSample->Start();
114 ASSERT_EQ(AV_ERR_OK, ret);
115 ret = vDecSample->Stop();
116 ASSERT_EQ(AV_ERR_OK, ret);
117 ret = vDecSample->Release();
118 ASSERT_EQ(AV_ERR_OK, ret);
119 }
120
121 /**
122 * @tc.number : VIDEO_SWDEC_STATE_0400
123 * @tc.name : create-configure-start-stop-reset
124 * @tc.desc : function test
125 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0400, TestSize.Level2)126 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0400, TestSize.Level2)
127 {
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->Reset();
133 ASSERT_EQ(AV_ERR_OK, ret);
134 }
135
136 /**
137 * @tc.number : VIDEO_SWDEC_STATE_0500
138 * @tc.name : create-configure-start-stop-error
139 * @tc.desc : function test
140 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0500, TestSize.Level2)141 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0500, TestSize.Level2)
142 {
143 int32_t ret = vDecSample->Start();
144 ASSERT_EQ(AV_ERR_OK, ret);
145 ret = vDecSample->Stop();
146 ASSERT_EQ(AV_ERR_OK, ret);
147 ret = vDecSample->Flush();
148 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
149 ret = vDecSample->SetVideoDecoderCallback();
150 ASSERT_EQ(AV_ERR_OK, ret);
151 }
152
153 /**
154 * @tc.number : VIDEO_SWDEC_STATE_0600
155 * @tc.name : create-configure-start-EOS-stop-start
156 * @tc.desc : function test
157 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0600, TestSize.Level2)158 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0600, TestSize.Level2)
159 {
160 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
161 int32_t ret = vDecSample->StartVideoDecoder();
162 ASSERT_EQ(AV_ERR_OK, ret);
163 vDecSample->WaitForEOS();
164 ASSERT_EQ(AV_ERR_OK, ret);
165 ASSERT_EQ(0, vDecSample->errCount);
166 ret = vDecSample->Stop();
167 ASSERT_EQ(AV_ERR_OK, ret);
168 ret = vDecSample->Start();
169 ASSERT_EQ(AV_ERR_OK, ret);
170 }
171
172 /**
173 * @tc.number : VIDEO_SWDEC_STATE_0700
174 * @tc.name : create-configure-start-EOS-stop-release
175 * @tc.desc : function test
176 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0700, TestSize.Level2)177 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0700, TestSize.Level2)
178 {
179 int32_t ret = vDecSample->StartVideoDecoder();
180 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
181 vDecSample->WaitForEOS();
182 ASSERT_EQ(AV_ERR_OK, ret);
183 ASSERT_EQ(0, vDecSample->errCount);
184 ret = vDecSample->Stop();
185 ASSERT_EQ(AV_ERR_OK, ret);
186 ret = vDecSample->Release();
187 ASSERT_EQ(AV_ERR_OK, ret);
188 }
189
190 /**
191 * @tc.number : VIDEO_SWDEC_STATE_0800
192 * @tc.name : create-configure-start-EOS-stop-reset
193 * @tc.desc : function test
194 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0800, TestSize.Level2)195 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0800, TestSize.Level2)
196 {
197 int32_t ret = vDecSample->StartVideoDecoder();
198 ASSERT_EQ(AV_ERR_OK, ret);
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->Reset();
206 ASSERT_EQ(AV_ERR_OK, ret);
207 }
208
209 /**
210 * @tc.number : VIDEO_SWDEC_STATE_0900
211 * @tc.name : create-configure-start-EOS-flush
212 * @tc.desc : function test
213 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0900, TestSize.Level2)214 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_0900, TestSize.Level2)
215 {
216 int32_t ret = vDecSample->StartVideoDecoder();
217 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
218 vDecSample->WaitForEOS();
219 ASSERT_EQ(AV_ERR_OK, ret);
220 ASSERT_EQ(0, vDecSample->errCount);
221 ret = vDecSample->Flush();
222 ASSERT_EQ(AV_ERR_OK, ret);
223 }
224
225 /**
226 * @tc.number : VIDEO_SWDEC_STATE_1000
227 * @tc.name : create-configure-start-EOS-flush-start
228 * @tc.desc : function test
229 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1000, TestSize.Level2)230 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1000, 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 ret = vDecSample->Start();
240 ASSERT_EQ(AV_ERR_OK, ret);
241 }
242
243 /**
244 * @tc.number : VIDEO_SWDEC_STATE_1100
245 * @tc.name : create-configure-start-EOS-flush-stop
246 * @tc.desc : function test
247 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1100, TestSize.Level2)248 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1100, TestSize.Level2)
249 {
250 int32_t ret = vDecSample->StartVideoDecoder();
251 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
252 vDecSample->WaitForEOS();
253 ASSERT_EQ(AV_ERR_OK, ret);
254 ASSERT_EQ(0, vDecSample->errCount);
255 ret = vDecSample->Flush();
256 ASSERT_EQ(AV_ERR_OK, ret);
257 ret = vDecSample->Stop();
258 ASSERT_EQ(AV_ERR_OK, ret);
259 }
260
261 /**
262 * @tc.number : VIDEO_SWDEC_STATE_1200
263 * @tc.name : create-configure-start-EOS-flush-reset
264 * @tc.desc : function test
265 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1200, TestSize.Level2)266 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1200, TestSize.Level2)
267 {
268 int32_t ret = vDecSample->StartVideoDecoder();
269 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
270 vDecSample->WaitForEOS();
271 ASSERT_EQ(AV_ERR_OK, ret);
272 ASSERT_EQ(0, vDecSample->errCount);
273 ret = vDecSample->Flush();
274 ASSERT_EQ(AV_ERR_OK, ret);
275 ret = vDecSample->Reset();
276 ASSERT_EQ(AV_ERR_OK, ret);
277 }
278
279 /**
280 * @tc.number : VIDEO_SWDEC_STATE_1300
281 * @tc.name : create-configure-start-EOS-flush-error
282 * @tc.desc : function test
283 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1300, TestSize.Level2)284 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1300, TestSize.Level2)
285 {
286 int32_t ret = vDecSample->StartVideoDecoder();
287 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
288 vDecSample->WaitForEOS();
289 ASSERT_EQ(AV_ERR_OK, ret);
290 ASSERT_EQ(0, vDecSample->errCount);
291 ret = vDecSample->Flush();
292 ASSERT_EQ(AV_ERR_OK, ret);
293 ret = vDecSample->Release();
294 ASSERT_EQ(AV_ERR_OK, ret);
295 ret = vDecSample->ConfigureVideoDecoder();
296 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
297 }
298
299 /**
300 * @tc.number : VIDEO_SWDEC_STATE_1400
301 * @tc.name : create-configure-start-EOS-reset-configure
302 * @tc.desc : function test
303 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1400, TestSize.Level2)304 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1400, TestSize.Level2)
305 {
306 int32_t ret = vDecSample->StartVideoDecoder();
307 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
308 vDecSample->WaitForEOS();
309 ASSERT_EQ(AV_ERR_OK, ret);
310 ASSERT_EQ(0, vDecSample->errCount);
311 ret = vDecSample->Reset();
312 ASSERT_EQ(AV_ERR_OK, ret);
313 ret = vDecSample->ConfigureVideoDecoder();
314 ASSERT_EQ(AV_ERR_OK, ret);
315 }
316
317 /**
318 * @tc.number : VIDEO_SWDEC_STATE_1500
319 * @tc.name : create-configure-start-EOS-reset-release
320 * @tc.desc : function test
321 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1500, TestSize.Level2)322 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1500, TestSize.Level2)
323 {
324 int32_t ret = vDecSample->StartVideoDecoder();
325 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
326 vDecSample->WaitForEOS();
327 ASSERT_EQ(AV_ERR_OK, ret);
328 ASSERT_EQ(0, vDecSample->errCount);
329 ret = vDecSample->Reset();
330 ASSERT_EQ(AV_ERR_OK, ret);
331 ret = vDecSample->Release();
332 ASSERT_EQ(AV_ERR_OK, ret);
333 }
334
335 /**
336 * @tc.number : VIDEO_SWDEC_STATE_1600
337 * @tc.name : create-configure-start-EOS-reset-error
338 * @tc.desc : function test
339 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1600, TestSize.Level2)340 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1600, TestSize.Level2)
341 {
342 int32_t ret = vDecSample->StartVideoDecoder();
343 vDecSample->AFTER_EOS_DESTORY_CODEC = false;
344 vDecSample->WaitForEOS();
345 ASSERT_EQ(AV_ERR_OK, ret);
346 ASSERT_EQ(0, vDecSample->errCount);
347 ret = vDecSample->Reset();
348 ASSERT_EQ(AV_ERR_OK, ret);
349 ret = vDecSample->Start();
350 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
351 ret = vDecSample->Stop();
352 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
353 ret = vDecSample->Flush();
354 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
355 }
356
357 /**
358 * @tc.number : VIDEO_SWDEC_STATE_1700
359 * @tc.name : create-configure-start-flush-start-flush
360 * @tc.desc : function test
361 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1700, TestSize.Level2)362 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1700, TestSize.Level2)
363 {
364 int32_t ret = vDecSample->Start();
365 ASSERT_EQ(AV_ERR_OK, ret);
366 ret = vDecSample->Flush();
367 ASSERT_EQ(AV_ERR_OK, ret);
368 ret = vDecSample->Start();
369 ASSERT_EQ(AV_ERR_OK, ret);
370 ret = vDecSample->Flush();
371 ASSERT_EQ(AV_ERR_OK, ret);
372 }
373
374 /**
375 * @tc.number : VIDEO_SWDEC_STATE_1800
376 * @tc.name : create-configure-start-flush-start-eos
377 * @tc.desc : function test
378 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1800, TestSize.Level2)379 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1800, TestSize.Level2)
380 {
381 int32_t ret = vDecSample->Start();
382 ASSERT_EQ(AV_ERR_OK, ret);
383 ret = vDecSample->Flush();
384 ASSERT_EQ(AV_ERR_OK, ret);
385 ret = vDecSample->Start();
386 ASSERT_EQ(AV_ERR_OK, ret);
387 ret = vDecSample->state_EOS();
388 ASSERT_EQ(AV_ERR_OK, ret);
389 }
390
391 /**
392 * @tc.number : VIDEO_SWDEC_STATE_1900
393 * @tc.name : create-configure-start-flush-start-stop
394 * @tc.desc : function test
395 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1900, TestSize.Level2)396 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_1900, TestSize.Level2)
397 {
398 int32_t ret = vDecSample->Start();
399 ASSERT_EQ(AV_ERR_OK, ret);
400 ret = vDecSample->Flush();
401 ASSERT_EQ(AV_ERR_OK, ret);
402 ret = vDecSample->Start();
403 ASSERT_EQ(AV_ERR_OK, ret);
404 ret = vDecSample->Stop();
405 ASSERT_EQ(AV_ERR_OK, ret);
406 }
407
408 /**
409 * @tc.number : VIDEO_SWDEC_STATE_2000
410 * @tc.name : create-configure-start-flush-start-reset
411 * @tc.desc : function test
412 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2000, TestSize.Level2)413 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2000, TestSize.Level2)
414 {
415 int32_t ret = vDecSample->Start();
416 ASSERT_EQ(AV_ERR_OK, ret);
417 ret = vDecSample->Flush();
418 ASSERT_EQ(AV_ERR_OK, ret);
419 ret = vDecSample->Start();
420 ASSERT_EQ(AV_ERR_OK, ret);
421 ret = vDecSample->Reset();
422 ASSERT_EQ(AV_ERR_OK, ret);
423 }
424
425 /**
426 * @tc.number : VIDEO_SWDEC_STATE_2100
427 * @tc.name : create-configure-start-flush-start-error
428 * @tc.desc : function test
429 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2100, TestSize.Level2)430 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2100, TestSize.Level2)
431 {
432 int32_t ret = vDecSample->Start();
433 ASSERT_EQ(AV_ERR_OK, ret);
434 ret = vDecSample->Flush();
435 ASSERT_EQ(AV_ERR_OK, ret);
436 ret = vDecSample->Start();
437 ASSERT_EQ(AV_ERR_OK, ret);
438 ret = vDecSample->ConfigureVideoDecoder();
439 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
440 ret = vDecSample->SetVideoDecoderCallback();
441 ASSERT_EQ(AV_ERR_OK, ret);
442 ret = vDecSample->Release();
443 ASSERT_EQ(AV_ERR_OK, ret);
444 }
445
446 /**
447 * @tc.number : VIDEO_SWDEC_STATE_2200
448 * @tc.name : create-configure-start-flush-start
449 * @tc.desc : function test
450 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2200, TestSize.Level2)451 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2200, TestSize.Level2)
452 {
453 int32_t ret = vDecSample->Start();
454 ASSERT_EQ(AV_ERR_OK, ret);
455 ret = vDecSample->Flush();
456 ASSERT_EQ(AV_ERR_OK, ret);
457 ret = vDecSample->Stop();
458 ASSERT_EQ(AV_ERR_OK, ret);
459 ret = vDecSample->Start();
460 ASSERT_EQ(AV_ERR_OK, ret);
461 }
462
463 /**
464 * @tc.number : VIDEO_SWDEC_STATE_2300
465 * @tc.name : create-configure-start-flush-stop-start
466 * @tc.desc : function test
467 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2300, TestSize.Level2)468 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2300, TestSize.Level2)
469 {
470 int32_t ret = vDecSample->Start();
471 ASSERT_EQ(AV_ERR_OK, ret);
472 ret = vDecSample->Flush();
473 ASSERT_EQ(AV_ERR_OK, ret);
474 ret = vDecSample->Stop();
475 ASSERT_EQ(AV_ERR_OK, ret);
476 ret = vDecSample->Release();
477 ASSERT_EQ(AV_ERR_OK, ret);
478 }
479
480 /**
481 * @tc.number : VIDEO_SWDEC_STATE_2400
482 * @tc.name : create-configure-start-flush-stop-reset
483 * @tc.desc : function test
484 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2400, TestSize.Level2)485 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2400, TestSize.Level2)
486 {
487 int32_t ret = vDecSample->Start();
488 ASSERT_EQ(AV_ERR_OK, ret);
489 ret = vDecSample->Flush();
490 ASSERT_EQ(AV_ERR_OK, ret);
491 ret = vDecSample->Stop();
492 ASSERT_EQ(AV_ERR_OK, ret);
493 ret = vDecSample->Reset();
494 ASSERT_EQ(AV_ERR_OK, ret);
495 }
496
497 /**
498 * @tc.number : VIDEO_SWDEC_STATE_2500
499 * @tc.name : create-configure-start-flush-stop-error
500 * @tc.desc : function test
501 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2500, TestSize.Level2)502 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2500, TestSize.Level2)
503 {
504 int32_t ret = vDecSample->Start();
505 ASSERT_EQ(AV_ERR_OK, ret);
506 ret = vDecSample->Flush();
507 ASSERT_EQ(AV_ERR_OK, ret);
508 ret = vDecSample->Stop();
509 ASSERT_EQ(AV_ERR_OK, ret);
510 ret = vDecSample->Flush();
511 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
512 ret = vDecSample->SetVideoDecoderCallback();
513 ASSERT_EQ(AV_ERR_OK, ret);
514 }
515
516 /**
517 * @tc.number : VIDEO_SWDEC_STATE_2600
518 * @tc.name : create-configure-start-flush-reset-configure
519 * @tc.desc : function test
520 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2600, TestSize.Level2)521 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2600, 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->Reset();
528 ASSERT_EQ(AV_ERR_OK, ret);
529 ret = vDecSample->ConfigureVideoDecoder();
530 ASSERT_EQ(AV_ERR_OK, ret);
531 }
532
533 /**
534 * @tc.number : VIDEO_SWDEC_STATE_2700
535 * @tc.name : create-configure-start-flush-reset-release
536 * @tc.desc : function test
537 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2700, TestSize.Level2)538 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2700, TestSize.Level2)
539 {
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->Reset();
545 ASSERT_EQ(AV_ERR_OK, ret);
546 ret = vDecSample->Release();
547 ASSERT_EQ(AV_ERR_OK, ret);
548 }
549
550 /**
551 * @tc.number : VIDEO_SWDEC_STATE_2800
552 * @tc.name : create-configure-start-flush-reset-error
553 * @tc.desc : function test
554 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2800, TestSize.Level2)555 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2800, TestSize.Level2)
556 {
557 int32_t ret = vDecSample->Start();
558 ASSERT_EQ(AV_ERR_OK, ret);
559 ret = vDecSample->Flush();
560 ASSERT_EQ(AV_ERR_OK, ret);
561 ret = vDecSample->Reset();
562 ASSERT_EQ(AV_ERR_OK, ret);
563 ret = vDecSample->Start();
564 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
565 ret = vDecSample->Stop();
566 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
567 ret = vDecSample->Flush();
568 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
569 ret = vDecSample->SetVideoDecoderCallback();
570 ASSERT_EQ(AV_ERR_OK, ret);
571 }
572
573 /**
574 * @tc.number : VIDEO_SWDEC_STATE_2900
575 * @tc.name : create-configure-start-reset-configure
576 * @tc.desc : function test
577 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2900, TestSize.Level2)578 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_2900, TestSize.Level2)
579 {
580 int32_t ret = vDecSample->Start();
581 ASSERT_EQ(AV_ERR_OK, ret);
582 ret = vDecSample->Reset();
583 ASSERT_EQ(AV_ERR_OK, ret);
584 ret = vDecSample->ConfigureVideoDecoder();
585 ASSERT_EQ(AV_ERR_OK, ret);
586 }
587
588 /**
589 * @tc.number : VIDEO_SWDEC_STATE_3000
590 * @tc.name : create-configure-start-reset-release
591 * @tc.desc : function test
592 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3000, TestSize.Level2)593 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3000, TestSize.Level2)
594 {
595 int32_t ret = vDecSample->Start();
596 ASSERT_EQ(AV_ERR_OK, ret);
597 ret = vDecSample->Reset();
598 ASSERT_EQ(AV_ERR_OK, ret);
599 ret = vDecSample->Release();
600 ASSERT_EQ(AV_ERR_OK, ret);
601 }
602
603 /**
604 * @tc.number : VIDEO_SWDEC_STATE_3100
605 * @tc.name : create-configure-start-reset-error
606 * @tc.desc : function test
607 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3100, TestSize.Level2)608 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3100, TestSize.Level2)
609 {
610 int32_t ret = vDecSample->Start();
611 ASSERT_EQ(AV_ERR_OK, ret);
612 ret = vDecSample->Reset();
613 ASSERT_EQ(AV_ERR_OK, ret);
614 ret = vDecSample->Start();
615 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
616 ret = vDecSample->Stop();
617 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
618 ret = vDecSample->Flush();
619 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
620 ret = vDecSample->SetVideoDecoderCallback();
621 ASSERT_EQ(AV_ERR_OK, ret);
622 }
623
624 /**
625 * @tc.number : VIDEO_SWDEC_STATE_3200
626 * @tc.name : create-configure-start-error
627 * @tc.desc : function test
628 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3200, TestSize.Level2)629 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3200, TestSize.Level2)
630 {
631 int32_t ret = vDecSample->Start();
632 ASSERT_EQ(AV_ERR_OK, ret);
633 ret = vDecSample->ConfigureVideoDecoder();
634 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
635 ret = vDecSample->SetVideoDecoderCallback();
636 ASSERT_EQ(AV_ERR_OK, ret);
637 ret = vDecSample->Release();
638 ASSERT_EQ(AV_ERR_OK, ret);
639 }
640
641 /**
642 * @tc.number : VIDEO_SWDEC_STATE_3300
643 * @tc.name : create-configure-reset-configure
644 * @tc.desc : function test
645 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3300, TestSize.Level2)646 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3300, TestSize.Level2)
647 {
648 int32_t ret = vDecSample->Reset();
649 ASSERT_EQ(AV_ERR_OK, ret);
650 ret = vDecSample->ConfigureVideoDecoder();
651 ASSERT_EQ(AV_ERR_OK, ret);
652 }
653
654 /**
655 * @tc.number : VIDEO_SWDEC_STATE_3400
656 * @tc.name : create-configure-release
657 * @tc.desc : function test
658 */
HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3400, TestSize.Level2)659 HWTEST_F(SwdecStateNdkTest, VIDEO_SWDEC_STATE_3400, TestSize.Level2)
660 {
661 int32_t ret = vDecSample->Release();
662 ASSERT_EQ(AV_ERR_OK, ret);
663 }
664 } // namespace