1 /*
2 * Copyright (C) 2024 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 #include <string>
16 #include "gtest/gtest.h"
17 #include "native_avcodec_videodecoder.h"
18 #include "native_averrors.h"
19 #include "videodec_api11_sample.h"
20 #include "native_avcodec_base.h"
21 #include "avcodec_codec_name.h"
22 #include "native_avcapability.h"
23 #include "native_buffer.h"
24
25 #define MAX_THREAD 16
26
27 using namespace std;
28 using namespace OHOS;
29 using namespace OHOS::Media;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Media {
34 class HwdecHdr2SdrStateNdkTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 void InputFunc();
41 void OutputFunc();
42 void Release();
43 int32_t Stop();
44 };
45 } // namespace Media
46 } // namespace OHOS
47
48 VDecAPI11Sample *vDecSample2 = NULL;
SetUpTestCase()49 void HwdecHdr2SdrStateNdkTest::SetUpTestCase() {}
TearDownTestCase()50 void HwdecHdr2SdrStateNdkTest::TearDownTestCase() {}
51
SetUp(void)52 void HwdecHdr2SdrStateNdkTest::SetUp(void)
53 {
54 vDecSample2 = new VDecAPI11Sample();
55 vDecSample2->SF_OUTPUT = true;
56 if (!access("/system/lib64/media/", 0)) {
57 vDecSample2->TRANSFER_FLAG = true;
58 } else {
59 vDecSample2->TRANSFER_FLAG = false;
60 }
61 OH_AVCapability *cap_hevc2 = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
62 string g_codecNameHEVC2 = OH_AVCapability_GetName(cap_hevc2);
63 cout << "g_codecNameHEVC2: " << g_codecNameHEVC2 << endl;
64 int32_t ret = vDecSample2->CreateVideoDecoder(g_codecNameHEVC2);
65 ASSERT_EQ(AV_ERR_OK, ret);
66 ret = vDecSample2->SetVideoDecoderCallback();
67 ASSERT_EQ(AV_ERR_OK, ret);
68 ret = vDecSample2->ConfigureVideoDecoder();
69 ASSERT_EQ(AV_ERR_OK, ret);
70 vDecSample2->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
71 }
72
TearDown()73 void HwdecHdr2SdrStateNdkTest::TearDown()
74 {
75 vDecSample2->Release();
76 delete vDecSample2;
77 vDecSample2 = nullptr;
78 }
79
80 namespace {
81 /**
82 * @tc.number : HEVC_HW_HDR2SDR_STATE_0099
83 * @tc.name : create-configure-start-EOS-stop-start-surface
84 * @tc.desc : function test
85 */
86 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0099, TestSize.Level2)
87 {
88 vDecSample2->SF_OUTPUT = true;
89 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
90 int32_t ret = vDecSample2->DecodeSetSurface();
91 ASSERT_EQ(AV_ERR_OK, ret);
92 ret = vDecSample2->StartVideoDecoder();
93 ASSERT_EQ(AV_ERR_OK, ret);
94 vDecSample2->WaitForEOS();
95 ASSERT_EQ(AV_ERR_OK, ret);
96 ASSERT_EQ(0, vDecSample2->errCount);
97 ret = vDecSample2->Stop();
98 ASSERT_EQ(AV_ERR_OK, ret);
99 ret = vDecSample2->Start();
100 ASSERT_EQ(AV_ERR_OK, ret);
101 }
102
103 /**
104 * @tc.number : HEVC_HW_HDR2SDR_STATE_0100
105 * @tc.name : create-configure-start-EOS-stop-release-surface
106 * @tc.desc : function test
107 */
108 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0100, TestSize.Level2)
109 {
110 vDecSample2->SF_OUTPUT = true;
111 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
112 int32_t ret = vDecSample2->DecodeSetSurface();
113 ASSERT_EQ(AV_ERR_OK, ret);
114 ret = vDecSample2->StartVideoDecoder();
115 ASSERT_EQ(AV_ERR_OK, ret);
116 vDecSample2->WaitForEOS();
117 ASSERT_EQ(AV_ERR_OK, ret);
118 ASSERT_EQ(0, vDecSample2->errCount);
119 ret = vDecSample2->Stop();
120 ASSERT_EQ(AV_ERR_OK, ret);
121 ret = vDecSample2->Release();
122 ASSERT_EQ(AV_ERR_OK, ret);
123 }
124
125 /**
126 * @tc.number : HEVC_HW_HDR2SDR_STATE_0200
127 * @tc.name : create-configure-start-EOS-stop-reset-surface
128 * @tc.desc : function test
129 */
130 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0200, TestSize.Level2)
131 {
132 vDecSample2->SF_OUTPUT = true;
133 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
134 int32_t ret = vDecSample2->DecodeSetSurface();
135 ASSERT_EQ(AV_ERR_OK, ret);
136 ret = vDecSample2->StartVideoDecoder();
137 ASSERT_EQ(AV_ERR_OK, ret);
138 vDecSample2->WaitForEOS();
139 ASSERT_EQ(AV_ERR_OK, ret);
140 ASSERT_EQ(0, vDecSample2->errCount);
141 ret = vDecSample2->Stop();
142 ASSERT_EQ(AV_ERR_OK, ret);
143 ret = vDecSample2->Reset();
144 ASSERT_EQ(AV_ERR_OK, ret);
145 }
146
147 /**
148 * @tc.number : HEVC_HW_HDR2SDR_STATE_0300
149 * @tc.name : create-configure-start-EOS-flush-surface
150 * @tc.desc : function test
151 */
152 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0300, TestSize.Level2)
153 {
154 vDecSample2->SF_OUTPUT = true;
155 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
156 int32_t ret = vDecSample2->DecodeSetSurface();
157 ASSERT_EQ(AV_ERR_OK, ret);
158 ret = vDecSample2->StartVideoDecoder();
159 ASSERT_EQ(AV_ERR_OK, ret);
160 vDecSample2->WaitForEOS();
161 ASSERT_EQ(AV_ERR_OK, ret);
162 ASSERT_EQ(0, vDecSample2->errCount);
163 ret = vDecSample2->Flush();
164 ASSERT_EQ(AV_ERR_OK, ret);
165 }
166
167 /**
168 * @tc.number : HEVC_HW_HDR2SDR_STATE_0400
169 * @tc.name : create-configure-start-EOS-flush-start-surface
170 * @tc.desc : function test
171 */
172 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0400, TestSize.Level2)
173 {
174 vDecSample2->SF_OUTPUT = true;
175 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
176 int32_t ret = vDecSample2->DecodeSetSurface();
177 ASSERT_EQ(AV_ERR_OK, ret);
178 ret = vDecSample2->StartVideoDecoder();
179 ASSERT_EQ(AV_ERR_OK, ret);
180 vDecSample2->WaitForEOS();
181 ASSERT_EQ(AV_ERR_OK, ret);
182 ASSERT_EQ(0, vDecSample2->errCount);
183 ret = vDecSample2->Flush();
184 ASSERT_EQ(AV_ERR_OK, ret);
185 ret = vDecSample2->Start();
186 ASSERT_EQ(AV_ERR_OK, ret);
187 }
188
189 /**
190 * @tc.number : HEVC_HW_HDR2SDR_STATE_0500
191 * @tc.name : create-configure-start-EOS-flush-stop-surface
192 * @tc.desc : function test
193 */
194 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0500, TestSize.Level2)
195 {
196 vDecSample2->SF_OUTPUT = true;
197 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
198 int32_t ret = vDecSample2->DecodeSetSurface();
199 ASSERT_EQ(AV_ERR_OK, ret);
200 ret = vDecSample2->StartVideoDecoder();
201 ASSERT_EQ(AV_ERR_OK, ret);
202 vDecSample2->WaitForEOS();
203 ASSERT_EQ(AV_ERR_OK, ret);
204 ASSERT_EQ(0, vDecSample2->errCount);
205 ret = vDecSample2->Flush();
206 ASSERT_EQ(AV_ERR_OK, ret);
207 ret = vDecSample2->Stop();
208 ASSERT_EQ(AV_ERR_OK, ret);
209 }
210
211 /**
212 * @tc.number : HEVC_HW_HDR2SDR_STATE_0600
213 * @tc.name : create-configure-start-EOS-flush-reset-surface
214 * @tc.desc : function test
215 */
216 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0600, TestSize.Level2)
217 {
218 vDecSample2->SF_OUTPUT = true;
219 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
220 int32_t ret = vDecSample2->DecodeSetSurface();
221 ASSERT_EQ(AV_ERR_OK, ret);
222 ret = vDecSample2->StartVideoDecoder();
223 ASSERT_EQ(AV_ERR_OK, ret);
224 vDecSample2->WaitForEOS();
225 ASSERT_EQ(AV_ERR_OK, ret);
226 ASSERT_EQ(0, vDecSample2->errCount);
227 ret = vDecSample2->Flush();
228 ASSERT_EQ(AV_ERR_OK, ret);
229 ret = vDecSample2->Reset();
230 ASSERT_EQ(AV_ERR_OK, ret);
231 }
232
233 /**
234 * @tc.number : HEVC_HW_HDR2SDR_STATE_0700
235 * @tc.name : create-configure-start-EOS-flush-error-surface
236 * @tc.desc : function test
237 */
238 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0700, TestSize.Level2)
239 {
240 vDecSample2->SF_OUTPUT = true;
241 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
242 int32_t ret = vDecSample2->DecodeSetSurface();
243 ASSERT_EQ(AV_ERR_OK, ret);
244 ret = vDecSample2->StartVideoDecoder();
245 ASSERT_EQ(AV_ERR_OK, ret);
246 vDecSample2->WaitForEOS();
247 ASSERT_EQ(AV_ERR_OK, ret);
248 ASSERT_EQ(0, vDecSample2->errCount);
249 ret = vDecSample2->Flush();
250 ASSERT_EQ(AV_ERR_OK, ret);
251 ret = vDecSample2->Release();
252 ASSERT_EQ(AV_ERR_OK, ret);
253 ret = vDecSample2->ConfigureVideoDecoder();
254 ASSERT_EQ(AV_ERR_INVALID_VAL, ret);
255 }
256
257 /**
258 * @tc.number : HEVC_HW_HDR2SDR_STATE_0800
259 * @tc.name : create-configure-start-EOS-reset-configure-surface
260 * @tc.desc : function test
261 */
262 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0800, TestSize.Level2)
263 {
264 vDecSample2->SF_OUTPUT = true;
265 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
266 int32_t ret = vDecSample2->DecodeSetSurface();
267 ASSERT_EQ(AV_ERR_OK, ret);
268 ret = vDecSample2->StartVideoDecoder();
269 ASSERT_EQ(AV_ERR_OK, ret);
270 vDecSample2->WaitForEOS();
271 ASSERT_EQ(AV_ERR_OK, ret);
272 ASSERT_EQ(0, vDecSample2->errCount);
273 ret = vDecSample2->Reset();
274 ASSERT_EQ(AV_ERR_OK, ret);
275 ret = vDecSample2->ConfigureVideoDecoder();
276 ASSERT_EQ(AV_ERR_OK, ret);
277 }
278
279 /**
280 * @tc.number : HEVC_HW_HDR2SDR_STATE_0900
281 * @tc.name : create-configure-start-EOS-reset-release-surface
282 * @tc.desc : function test
283 */
284 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_0900, TestSize.Level2)
285 {
286 vDecSample2->SF_OUTPUT = true;
287 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
288 int32_t ret = vDecSample2->DecodeSetSurface();
289 ASSERT_EQ(AV_ERR_OK, ret);
290 ret = vDecSample2->StartVideoDecoder();
291 ASSERT_EQ(AV_ERR_OK, ret);
292 vDecSample2->WaitForEOS();
293 ASSERT_EQ(AV_ERR_OK, ret);
294 ASSERT_EQ(0, vDecSample2->errCount);
295 ret = vDecSample2->Reset();
296 ASSERT_EQ(AV_ERR_OK, ret);
297 ret = vDecSample2->Release();
298 ASSERT_EQ(AV_ERR_OK, ret);
299 }
300
301 /**
302 * @tc.number : HEVC_HW_HDR2SDR_STATE_1000
303 * @tc.name : create-configure-start-EOS-reset-error-surface
304 * @tc.desc : function test
305 */
306 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1000, TestSize.Level2)
307 {
308 vDecSample2->SF_OUTPUT = true;
309 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
310 int32_t ret = vDecSample2->DecodeSetSurface();
311 ASSERT_EQ(AV_ERR_OK, ret);
312 ret = vDecSample2->StartVideoDecoder();
313 ASSERT_EQ(AV_ERR_OK, ret);
314 vDecSample2->WaitForEOS();
315 ASSERT_EQ(AV_ERR_OK, ret);
316 ASSERT_EQ(0, vDecSample2->errCount);
317 ret = vDecSample2->Reset();
318 ASSERT_EQ(AV_ERR_OK, ret);
319 ret = vDecSample2->Start();
320 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
321 ret = vDecSample2->Stop();
322 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
323 ret = vDecSample2->Flush();
324 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
325 }
326
327 /**
328 * @tc.number : HEVC_HW_HDR2SDR_STATE_1100
329 * @tc.name : create-configure-error-surface
330 * @tc.desc : function test
331 */
332 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1100, TestSize.Level2)
333 {
334 vDecSample2->SF_OUTPUT = true;
335 int32_t ret = vDecSample2->DecodeSetSurface();
336 ASSERT_EQ(AV_ERR_OK, ret);
337 ret = vDecSample2->Flush();
338 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
339 ret = vDecSample2->SetVideoDecoderCallback();
340 ASSERT_EQ(AV_ERR_OK, ret);
341 }
342
343 /**
344 * @tc.number : HEVC_HW_HDR2SDR_STATE_1101
345 * @tc.name : create-configure-setsurface-stop
346 * @tc.desc : function test
347 */
348 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1101, TestSize.Level2)
349 {
350 vDecSample2->SF_OUTPUT = true;
351 int32_t ret = vDecSample2->DecodeSetSurface();
352 ASSERT_EQ(AV_ERR_OK, ret);
353 ret = vDecSample2->Stop();
354 ASSERT_EQ(AV_ERR_OK, ret);
355 }
356
357 /**
358 * @tc.number : HEVC_HW_HDR2SDR_STATE_1200
359 * @tc.name : create-configure-start-stop-start-surface
360 * @tc.desc : function test
361 */
362 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1200, TestSize.Level2)
363 {
364 vDecSample2->SF_OUTPUT = true;
365 int32_t ret = vDecSample2->DecodeSetSurface();
366 ASSERT_EQ(AV_ERR_OK, ret);
367 ret = vDecSample2->Prepare();
368 ASSERT_EQ(AV_ERR_OK, ret);
369 ret = vDecSample2->Start();
370 ASSERT_EQ(AV_ERR_OK, ret);
371 ret = vDecSample2->Stop();
372 ASSERT_EQ(AV_ERR_OK, ret);
373 ret = vDecSample2->Start();
374 ASSERT_EQ(AV_ERR_OK, ret);
375 }
376
377 /**
378 * @tc.number : HEVC_HW_HDR2SDR_STATE_1300
379 * @tc.name : create-configure-start-stop-release-surface
380 * @tc.desc : function test
381 */
382 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1300, TestSize.Level2)
383 {
384 vDecSample2->SF_OUTPUT = true;
385 int32_t ret = vDecSample2->DecodeSetSurface();
386 ASSERT_EQ(AV_ERR_OK, ret);
387 ret = vDecSample2->Prepare();
388 ASSERT_EQ(AV_ERR_OK, ret);
389 ret = vDecSample2->Start();
390 ASSERT_EQ(AV_ERR_OK, ret);
391 ret = vDecSample2->Stop();
392 ASSERT_EQ(AV_ERR_OK, ret);
393 ret = vDecSample2->Release();
394 ASSERT_EQ(AV_ERR_OK, ret);
395 }
396
397 /**
398 * @tc.number : HEVC_HW_HDR2SDR_STATE_1400
399 * @tc.name : create-configure-start-stop-reset-surface
400 * @tc.desc : function test
401 */
402 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1400, TestSize.Level2)
403 {
404 vDecSample2->SF_OUTPUT = true;
405 int32_t ret = vDecSample2->DecodeSetSurface();
406 ASSERT_EQ(AV_ERR_OK, ret);
407 ret = vDecSample2->Prepare();
408 ASSERT_EQ(AV_ERR_OK, ret);
409 ret = vDecSample2->Start();
410 ASSERT_EQ(AV_ERR_OK, ret);
411 ret = vDecSample2->Stop();
412 ASSERT_EQ(AV_ERR_OK, ret);
413 ret = vDecSample2->Reset();
414 ASSERT_EQ(AV_ERR_OK, ret);
415 }
416
417 /**
418 * @tc.number : HEVC_HW_HDR2SDR_STATE_1500
419 * @tc.name : create-configure-start-stop-error-surface
420 * @tc.desc : function test
421 */
422 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1500, TestSize.Level2)
423 {
424 vDecSample2->SF_OUTPUT = true;
425 int32_t ret = vDecSample2->DecodeSetSurface();
426 ASSERT_EQ(AV_ERR_OK, ret);
427 ret = vDecSample2->Prepare();
428 ASSERT_EQ(AV_ERR_OK, ret);
429 ret = vDecSample2->Start();
430 ASSERT_EQ(AV_ERR_OK, ret);
431 ret = vDecSample2->Stop();
432 ASSERT_EQ(AV_ERR_OK, ret);
433 ret = vDecSample2->Flush();
434 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
435 ret = vDecSample2->SetVideoDecoderCallback();
436 ASSERT_EQ(AV_ERR_OK, ret);
437 }
438
439 /**
440 * @tc.number : HEVC_HW_HDR2SDR_STATE_1600
441 * @tc.name : create-configure-start-EOS-reset-error-surface
442 * @tc.desc : function test
443 */
444 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1600, TestSize.Level2)
445 {
446 vDecSample2->SF_OUTPUT = true;
447 int32_t ret = vDecSample2->DecodeSetSurface();
448 ASSERT_EQ(AV_ERR_OK, ret);
449 ret = vDecSample2->StartVideoDecoder();
450 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
451 vDecSample2->WaitForEOS();
452 ASSERT_EQ(AV_ERR_OK, ret);
453 ASSERT_EQ(0, vDecSample2->errCount);
454 ret = vDecSample2->Reset();
455 ASSERT_EQ(AV_ERR_OK, ret);
456 ret = vDecSample2->Start();
457 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
458 ret = vDecSample2->Stop();
459 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
460 ret = vDecSample2->Flush();
461 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
462 }
463
464 /**
465 * @tc.number : HEVC_HW_HDR2SDR_STATE_1700
466 * @tc.name : create-configure-start-flush-start-flush-surface
467 * @tc.desc : function test
468 */
469 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1700, TestSize.Level2)
470 {
471 vDecSample2->SF_OUTPUT = true;
472 int32_t ret = vDecSample2->DecodeSetSurface();
473 ASSERT_EQ(AV_ERR_OK, ret);
474 ret = vDecSample2->Prepare();
475 ASSERT_EQ(AV_ERR_OK, ret);
476 ret = vDecSample2->Start();
477 ASSERT_EQ(AV_ERR_OK, ret);
478 ret = vDecSample2->Flush();
479 ASSERT_EQ(AV_ERR_OK, ret);
480 ret = vDecSample2->Start();
481 ASSERT_EQ(AV_ERR_OK, ret);
482 ret = vDecSample2->Flush();
483 ASSERT_EQ(AV_ERR_OK, ret);
484 }
485
486 /**
487 * @tc.number : HEVC_HW_HDR2SDR_STATE_1800
488 * @tc.name : create-configure-start-flush-start-eos-surface
489 * @tc.desc : function test
490 */
491 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1800, TestSize.Level2)
492 {
493 vDecSample2->SF_OUTPUT = true;
494 int32_t ret = vDecSample2->DecodeSetSurface();
495 ASSERT_EQ(AV_ERR_OK, ret);
496 ret = vDecSample2->Prepare();
497 ASSERT_EQ(AV_ERR_OK, ret);
498 ret = vDecSample2->Start();
499 ASSERT_EQ(AV_ERR_OK, ret);
500 ret = vDecSample2->Flush();
501 ASSERT_EQ(AV_ERR_OK, ret);
502 ret = vDecSample2->Start();
503 ASSERT_EQ(AV_ERR_OK, ret);
504 ret = vDecSample2->state_EOS();
505 ASSERT_EQ(AV_ERR_OK, ret);
506 }
507
508 /**
509 * @tc.number : HEVC_HW_HDR2SDR_STATE_1900
510 * @tc.name : create-configure-start-flush-start-stop-surface
511 * @tc.desc : function test
512 */
513 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1900, TestSize.Level2)
514 {
515 vDecSample2->SF_OUTPUT = true;
516 int32_t ret = vDecSample2->DecodeSetSurface();
517 ASSERT_EQ(AV_ERR_OK, ret);
518 ret = vDecSample2->Prepare();
519 ASSERT_EQ(AV_ERR_OK, ret);
520 ret = vDecSample2->Start();
521 ASSERT_EQ(AV_ERR_OK, ret);
522 ret = vDecSample2->Flush();
523 ASSERT_EQ(AV_ERR_OK, ret);
524 ret = vDecSample2->Start();
525 ASSERT_EQ(AV_ERR_OK, ret);
526 ret = vDecSample2->Stop();
527 ASSERT_EQ(AV_ERR_OK, ret);
528 }
529
530 /**
531 * @tc.number : HEVC_HW_HDR2SDR_STATE_2000
532 * @tc.name : create-configure-start-flush-start-reset-surface
533 * @tc.desc : function test
534 */
535 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2000, TestSize.Level2)
536 {
537 vDecSample2->SF_OUTPUT = true;
538 int32_t ret = vDecSample2->DecodeSetSurface();
539 ASSERT_EQ(AV_ERR_OK, ret);
540 ret = vDecSample2->Prepare();
541 ASSERT_EQ(AV_ERR_OK, ret);
542 ret = vDecSample2->Start();
543 ASSERT_EQ(AV_ERR_OK, ret);
544 ret = vDecSample2->Flush();
545 ASSERT_EQ(AV_ERR_OK, ret);
546 ret = vDecSample2->Start();
547 ASSERT_EQ(AV_ERR_OK, ret);
548 ret = vDecSample2->Reset();
549 ASSERT_EQ(AV_ERR_OK, ret);
550 }
551
552 /**
553 * @tc.number : HEVC_HW_HDR2SDR_STATE_2100
554 * @tc.name : create-configure-start-flush-start-error-surface
555 * @tc.desc : function test
556 */
557 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2100, TestSize.Level2)
558 {
559 vDecSample2->SF_OUTPUT = true;
560 int32_t ret = vDecSample2->DecodeSetSurface();
561 ASSERT_EQ(AV_ERR_OK, ret);
562 ret = vDecSample2->Prepare();
563 ASSERT_EQ(AV_ERR_OK, ret);
564 ret = vDecSample2->Start();
565 ASSERT_EQ(AV_ERR_OK, ret);
566 ret = vDecSample2->Flush();
567 ASSERT_EQ(AV_ERR_OK, ret);
568 ret = vDecSample2->Start();
569 ASSERT_EQ(AV_ERR_OK, ret);
570 ret = vDecSample2->ConfigureVideoDecoder();
571 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
572 ret = vDecSample2->SetVideoDecoderCallback();
573 ASSERT_EQ(AV_ERR_OK, ret);
574 ret = vDecSample2->Release();
575 ASSERT_EQ(AV_ERR_OK, ret);
576 }
577
578 /**
579 * @tc.number : HEVC_HW_HDR2SDR_STATE_2200
580 * @tc.name : create-configure-start-flush-start-error-surface
581 * @tc.desc : function test
582 */
583 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2200, TestSize.Level2)
584 {
585 vDecSample2->SF_OUTPUT = true;
586 int32_t ret = vDecSample2->DecodeSetSurface();
587 ASSERT_EQ(AV_ERR_OK, ret);
588 ret = vDecSample2->Prepare();
589 ASSERT_EQ(AV_ERR_OK, ret);
590 ret = vDecSample2->Start();
591 ASSERT_EQ(AV_ERR_OK, ret);
592 ret = vDecSample2->Flush();
593 ASSERT_EQ(AV_ERR_OK, ret);
594 ret = vDecSample2->Stop();
595 ASSERT_EQ(AV_ERR_OK, ret);
596 ret = vDecSample2->Start();
597 ASSERT_EQ(AV_ERR_OK, ret);
598 cout << "set callback" << endl;
599 ret = vDecSample2->SetVideoDecoderCallback();
600 ASSERT_EQ(AV_ERR_OK, ret);
601 }
602
603 /**
604 * @tc.number : HEVC_HW_HDR2SDR_STATE_2300
605 * @tc.name : create-configure-start-flush-stop-start-surface
606 * @tc.desc : function test
607 */
608 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2300, TestSize.Level2)
609 {
610 vDecSample2->SF_OUTPUT = true;
611 int32_t ret = vDecSample2->DecodeSetSurface();
612 ASSERT_EQ(AV_ERR_OK, ret);
613 ret = vDecSample2->Prepare();
614 ASSERT_EQ(AV_ERR_OK, ret);
615 ret = vDecSample2->Start();
616 ASSERT_EQ(AV_ERR_OK, ret);
617 ret = vDecSample2->Flush();
618 ASSERT_EQ(AV_ERR_OK, ret);
619 ret = vDecSample2->Stop();
620 ASSERT_EQ(AV_ERR_OK, ret);
621 ret = vDecSample2->Release();
622 ASSERT_EQ(AV_ERR_OK, ret);
623 }
624
625 /**
626 * @tc.number : HEVC_HW_HDR2SDR_STATE_2400
627 * @tc.name : create-configure-start-flush-stop-reset-surface
628 * @tc.desc : function test
629 */
630 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2400, TestSize.Level2)
631 {
632 vDecSample2->SF_OUTPUT = true;
633 int32_t ret = vDecSample2->DecodeSetSurface();
634 ASSERT_EQ(AV_ERR_OK, ret);
635 ret = vDecSample2->Prepare();
636 ASSERT_EQ(AV_ERR_OK, ret);
637 ret = vDecSample2->Start();
638 ASSERT_EQ(AV_ERR_OK, ret);
639 ret = vDecSample2->Flush();
640 ASSERT_EQ(AV_ERR_OK, ret);
641 ret = vDecSample2->Stop();
642 ASSERT_EQ(AV_ERR_OK, ret);
643 ret = vDecSample2->Reset();
644 ASSERT_EQ(AV_ERR_OK, ret);
645 }
646
647 /**
648 * @tc.number : HEVC_HW_HDR2SDR_STATE_2500
649 * @tc.name : create-configure-start-flush-stop-error-surface
650 * @tc.desc : function test
651 */
652 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2500, TestSize.Level2)
653 {
654 vDecSample2->SF_OUTPUT = true;
655 int32_t ret = vDecSample2->DecodeSetSurface();
656 ASSERT_EQ(AV_ERR_OK, ret);
657 ret = vDecSample2->Prepare();
658 ASSERT_EQ(AV_ERR_OK, ret);
659 ret = vDecSample2->Start();
660 ASSERT_EQ(AV_ERR_OK, ret);
661 ret = vDecSample2->Flush();
662 ASSERT_EQ(AV_ERR_OK, ret);
663 ret = vDecSample2->Stop();
664 ASSERT_EQ(AV_ERR_OK, ret);
665 ret = vDecSample2->Flush();
666 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
667 ret = vDecSample2->SetVideoDecoderCallback();
668 ASSERT_EQ(AV_ERR_OK, ret);
669 }
670
671 /**
672 * @tc.number : HEVC_HW_HDR2SDR_STATE_2600
673 * @tc.name : create-configure-start-flush-reset-configure-surface
674 * @tc.desc : function test
675 */
676 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2600, TestSize.Level2)
677 {
678 vDecSample2->SF_OUTPUT = true;
679 int32_t ret = vDecSample2->DecodeSetSurface();
680 ASSERT_EQ(AV_ERR_OK, ret);
681 ret = vDecSample2->Prepare();
682 ASSERT_EQ(AV_ERR_OK, ret);
683 ret = vDecSample2->Start();
684 ASSERT_EQ(AV_ERR_OK, ret);
685 ret = vDecSample2->Flush();
686 ASSERT_EQ(AV_ERR_OK, ret);
687 ret = vDecSample2->Reset();
688 ASSERT_EQ(AV_ERR_OK, ret);
689 ret = vDecSample2->ConfigureVideoDecoder();
690 ASSERT_EQ(AV_ERR_OK, ret);
691 }
692
693 /**
694 * @tc.number : HEVC_HW_HDR2SDR_STATE_2700
695 * @tc.name : create-configure-start-flush-reset-release-surface
696 * @tc.desc : function test
697 */
698 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2700, TestSize.Level2)
699 {
700 vDecSample2->SF_OUTPUT = true;
701 int32_t ret = vDecSample2->DecodeSetSurface();
702 ASSERT_EQ(AV_ERR_OK, ret);
703 ret = vDecSample2->Prepare();
704 ASSERT_EQ(AV_ERR_OK, ret);
705 ret = vDecSample2->Start();
706 ASSERT_EQ(AV_ERR_OK, ret);
707 ret = vDecSample2->Flush();
708 ASSERT_EQ(AV_ERR_OK, ret);
709 ret = vDecSample2->Reset();
710 ASSERT_EQ(AV_ERR_OK, ret);
711 ret = vDecSample2->Release();
712 ASSERT_EQ(AV_ERR_OK, ret);
713 }
714
715 /**
716 * @tc.number : HEVC_HW_HDR2SDR_STATE_2800
717 * @tc.name : create-configure-start-flush-reset-error-surface
718 * @tc.desc : function test
719 */
720 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2800, TestSize.Level2)
721 {
722 vDecSample2->SF_OUTPUT = true;
723 int32_t ret = vDecSample2->DecodeSetSurface();
724 ASSERT_EQ(AV_ERR_OK, ret);
725 ret = vDecSample2->Prepare();
726 ASSERT_EQ(AV_ERR_OK, ret);
727 ret = vDecSample2->Start();
728 ASSERT_EQ(AV_ERR_OK, ret);
729 ret = vDecSample2->Flush();
730 ASSERT_EQ(AV_ERR_OK, ret);
731 ret = vDecSample2->Reset();
732 ASSERT_EQ(AV_ERR_OK, ret);
733 ret = vDecSample2->Start();
734 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
735 ret = vDecSample2->Stop();
736 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
737 ret = vDecSample2->Flush();
738 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
739 ret = vDecSample2->SetVideoDecoderCallback();
740 ASSERT_EQ(AV_ERR_OK, ret);
741 }
742
743 /**
744 * @tc.number : HEVC_HW_HDR2SDR_STATE_2900
745 * @tc.name : create-configure-start-reset-configure-surface
746 * @tc.desc : function test
747 */
748 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2900, TestSize.Level2)
749 {
750 vDecSample2->SF_OUTPUT = true;
751 int32_t ret = vDecSample2->DecodeSetSurface();
752 ASSERT_EQ(AV_ERR_OK, ret);
753 ret = vDecSample2->Prepare();
754 ASSERT_EQ(AV_ERR_OK, ret);
755 ret = vDecSample2->Start();
756 ASSERT_EQ(AV_ERR_OK, ret);
757 ret = vDecSample2->Reset();
758 ASSERT_EQ(AV_ERR_OK, ret);
759 ret = vDecSample2->ConfigureVideoDecoder();
760 ASSERT_EQ(AV_ERR_OK, ret);
761 }
762
763 /**
764 * @tc.number : HEVC_HW_HDR2SDR_STATE_3000
765 * @tc.name : create-configure-start-reset-release-surface
766 * @tc.desc : function test
767 */
768 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3000, TestSize.Level2)
769 {
770 vDecSample2->SF_OUTPUT = true;
771 int32_t ret = vDecSample2->DecodeSetSurface();
772 ASSERT_EQ(AV_ERR_OK, ret);
773 ret = vDecSample2->Prepare();
774 ASSERT_EQ(AV_ERR_OK, ret);
775 ret = vDecSample2->Start();
776 ASSERT_EQ(AV_ERR_OK, ret);
777 ret = vDecSample2->Reset();
778 ASSERT_EQ(AV_ERR_OK, ret);
779 ret = vDecSample2->Release();
780 ASSERT_EQ(AV_ERR_OK, ret);
781 }
782
783 /**
784 * @tc.number : HEVC_HW_HDR2SDR_STATE_3100
785 * @tc.name : create-configure-start-reset-error-surface
786 * @tc.desc : function test
787 */
788 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3100, TestSize.Level2)
789 {
790 vDecSample2->SF_OUTPUT = true;
791 int32_t ret = vDecSample2->DecodeSetSurface();
792 ASSERT_EQ(AV_ERR_OK, ret);
793 ret = vDecSample2->Prepare();
794 ASSERT_EQ(AV_ERR_OK, ret);
795 ret = vDecSample2->Start();
796 ASSERT_EQ(AV_ERR_OK, ret);
797 ret = vDecSample2->Reset();
798 ASSERT_EQ(AV_ERR_OK, ret);
799 ret = vDecSample2->Start();
800 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
801 ret = vDecSample2->Stop();
802 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
803 ret = vDecSample2->Flush();
804 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
805 ret = vDecSample2->SetVideoDecoderCallback();
806 ASSERT_EQ(AV_ERR_OK, ret);
807 }
808
809 /**
810 * @tc.number : HEVC_HW_HDR2SDR_STATE_3200
811 * @tc.name : create-configure-start-error-surface
812 * @tc.desc : function test
813 */
814 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3200, TestSize.Level2)
815 {
816 vDecSample2->SF_OUTPUT = true;
817 int32_t ret = vDecSample2->DecodeSetSurface();
818 ASSERT_EQ(AV_ERR_OK, ret);
819 ret = vDecSample2->Prepare();
820 ASSERT_EQ(AV_ERR_OK, ret);
821 ret = vDecSample2->Start();
822 ASSERT_EQ(AV_ERR_OK, ret);
823 ret = vDecSample2->ConfigureVideoDecoder();
824 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
825 ret = vDecSample2->SetVideoDecoderCallback();
826 ASSERT_EQ(AV_ERR_OK, ret);
827 ret = vDecSample2->Release();
828 ASSERT_EQ(AV_ERR_OK, ret);
829 }
830
831 /**
832 * @tc.number : HEVC_HW_HDR2SDR_STATE_3300
833 * @tc.name : create-configure-reset-configure-surface
834 * @tc.desc : function test
835 */
836 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3300, TestSize.Level2)
837 {
838 vDecSample2->SF_OUTPUT = true;
839 int32_t ret = vDecSample2->DecodeSetSurface();
840 ASSERT_EQ(AV_ERR_OK, ret);
841 ret = vDecSample2->Reset();
842 ASSERT_EQ(AV_ERR_OK, ret);
843 ret = vDecSample2->ConfigureVideoDecoder();
844 ASSERT_EQ(AV_ERR_OK, ret);
845 }
846
847 /**
848 * @tc.number : HEVC_HW_HDR2SDR_STATE_3400
849 * @tc.name : create-configure-release-surface
850 * @tc.desc : function test
851 */
852 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3400, TestSize.Level2)
853 {
854 vDecSample2->SF_OUTPUT = true;
855 int32_t ret = vDecSample2->DecodeSetSurface();
856 ASSERT_EQ(AV_ERR_OK, ret);
857 ret = vDecSample2->Release();
858 ASSERT_EQ(AV_ERR_OK, ret);
859 }
860
861 /**
862 * @tc.number : HEVC_HW_HDR2SDR_STATE_3500
863 * @tc.name : Flush or stop in buffe decoder callback function-surface
864 * @tc.desc : function test
865 */
866 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3500, TestSize.Level1)
867 {
868 vDecSample2->SF_OUTPUT = true;
869 int32_t ret = vDecSample2->DecodeSetSurface();
870 ASSERT_EQ(AV_ERR_OK, ret);
871 vDecSample2->inputCallbackFlush = true;
872 ret = vDecSample2->StartVideoDecoder();
873 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
874 vDecSample2->WaitForEOS();
875 ASSERT_EQ(AV_ERR_OK, ret);
876 }
877
878 /**
879 * @tc.number : HEVC_HW_HDR2SDR_STATE_3600
880 * @tc.name : Flush or stop in buffe decoder callback function-surface
881 * @tc.desc : function test
882 */
883 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3600, TestSize.Level1)
884 {
885 vDecSample2->SF_OUTPUT = true;
886 int32_t ret = vDecSample2->DecodeSetSurface();
887 ASSERT_EQ(AV_ERR_OK, ret);
888 vDecSample2->inputCallbackStop = true;
889 ret = vDecSample2->StartVideoDecoder();
890 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
891 ASSERT_EQ(AV_ERR_OK, ret);
892 vDecSample2->WaitForEOS();
893 }
894
895 /**
896 * @tc.number : HEVC_HW_HDR2SDR_STATE_3700
897 * @tc.name : Flush or stop in buffe decoder callback function-surface
898 * @tc.desc : function test
899 */
900 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3700, TestSize.Level1)
901 {
902 vDecSample2->SF_OUTPUT = true;
903 int32_t ret = vDecSample2->DecodeSetSurface();
904 ASSERT_EQ(AV_ERR_OK, ret);
905 vDecSample2->outputCallbackFlush = true;
906 ret = vDecSample2->StartVideoDecoder();
907 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
908 ASSERT_EQ(AV_ERR_OK, ret);
909 vDecSample2->WaitForEOS();
910 }
911
912 /**
913 * @tc.number : HEVC_HW_HDR2SDR_STATE_3800
914 * @tc.name : Flush or stop in buffe decoder callback function-surface
915 * @tc.desc : function test
916 */
917 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3800, TestSize.Level1)
918 {
919 vDecSample2->SF_OUTPUT = true;
920 int32_t ret = vDecSample2->DecodeSetSurface();
921 ASSERT_EQ(AV_ERR_OK, ret);
922 vDecSample2->outputCallbackStop = true;
923 ret = vDecSample2->StartVideoDecoder();
924 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
925 ASSERT_EQ(AV_ERR_OK, ret);
926 vDecSample2->WaitForEOS();
927 }
928
929 /**
930 * @tc.number : HEVC_HW_HDR2SDR_STATE_3900
931 * @tc.name : Flush or stop in surf decoder callback function-surface
932 * @tc.desc : function test
933 */
934 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3900, TestSize.Level1)
935 {
936 vDecSample2->SF_OUTPUT = true;
937 int32_t ret = vDecSample2->DecodeSetSurface();
938 ASSERT_EQ(AV_ERR_OK, ret);
939 vDecSample2->SF_OUTPUT = true;
940 vDecSample2->inputCallbackFlush = true;
941 ret = vDecSample2->StartVideoDecoder();
942 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
943 vDecSample2->WaitForEOS();
944 ASSERT_EQ(AV_ERR_OK, ret);
945 }
946
947 /**
948 * @tc.number : HEVC_HW_HDR2SDR_STATE_4000
949 * @tc.name : Flush or stop in buffe decoder callback function-surface
950 * @tc.desc : function test
951 */
952 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4000, TestSize.Level1)
953 {
954 vDecSample2->SF_OUTPUT = true;
955 int32_t ret = vDecSample2->DecodeSetSurface();
956 ASSERT_EQ(AV_ERR_OK, ret);
957 vDecSample2->SF_OUTPUT = true;
958 vDecSample2->inputCallbackStop = true;
959 ret = vDecSample2->StartVideoDecoder();
960 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
961 ASSERT_EQ(AV_ERR_OK, ret);
962 vDecSample2->WaitForEOS();
963 }
964
965 /**
966 * @tc.number : HEVC_HW_HDR2SDR_STATE_4100
967 * @tc.name : Flush or stop in buffe decoder callback function-surface
968 * @tc.desc : function test
969 */
970 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4100, TestSize.Level1)
971 {
972 vDecSample2->SF_OUTPUT = true;
973 int32_t ret = vDecSample2->DecodeSetSurface();
974 ASSERT_EQ(AV_ERR_OK, ret);
975 vDecSample2->SF_OUTPUT = true;
976 vDecSample2->outputCallbackFlush = true;
977 ret = vDecSample2->StartVideoDecoder();
978 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
979 ASSERT_EQ(AV_ERR_OK, ret);
980 vDecSample2->WaitForEOS();
981 }
982
983 /**
984 * @tc.number : HEVC_HW_HDR2SDR_STATE_4200
985 * @tc.name : Flush or stop in buffe decoder callback function-surface
986 * @tc.desc : function test
987 */
988 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4200, TestSize.Level1)
989 {
990 vDecSample2->SF_OUTPUT = true;
991 int32_t ret = vDecSample2->DecodeSetSurface();
992 ASSERT_EQ(AV_ERR_OK, ret);
993 vDecSample2->SF_OUTPUT = true;
994 vDecSample2->outputCallbackStop = true;
995 ret = vDecSample2->StartVideoDecoder();
996 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
997 ASSERT_EQ(AV_ERR_OK, ret);
998 vDecSample2->WaitForEOS();
999 }
1000 } //namespace