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