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->Stop();
338 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
339 ret = vDecSample2->Flush();
340 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
341 ret = vDecSample2->SetVideoDecoderCallback();
342 ASSERT_EQ(AV_ERR_OK, ret);
343 }
344
345 /**
346 * @tc.number : HEVC_HW_HDR2SDR_STATE_1200
347 * @tc.name : create-configure-start-stop-start-surface
348 * @tc.desc : function test
349 */
350 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1200, TestSize.Level2)
351 {
352 vDecSample2->SF_OUTPUT = true;
353 int32_t ret = vDecSample2->DecodeSetSurface();
354 ASSERT_EQ(AV_ERR_OK, ret);
355 ret = vDecSample2->Prepare();
356 ASSERT_EQ(AV_ERR_OK, ret);
357 ret = vDecSample2->Start();
358 ASSERT_EQ(AV_ERR_OK, ret);
359 ret = vDecSample2->Stop();
360 ASSERT_EQ(AV_ERR_OK, ret);
361 ret = vDecSample2->Start();
362 ASSERT_EQ(AV_ERR_OK, ret);
363 }
364
365 /**
366 * @tc.number : HEVC_HW_HDR2SDR_STATE_1300
367 * @tc.name : create-configure-start-stop-release-surface
368 * @tc.desc : function test
369 */
370 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1300, TestSize.Level2)
371 {
372 vDecSample2->SF_OUTPUT = true;
373 int32_t ret = vDecSample2->DecodeSetSurface();
374 ASSERT_EQ(AV_ERR_OK, ret);
375 ret = vDecSample2->Prepare();
376 ASSERT_EQ(AV_ERR_OK, ret);
377 ret = vDecSample2->Start();
378 ASSERT_EQ(AV_ERR_OK, ret);
379 ret = vDecSample2->Stop();
380 ASSERT_EQ(AV_ERR_OK, ret);
381 ret = vDecSample2->Release();
382 ASSERT_EQ(AV_ERR_OK, ret);
383 }
384
385 /**
386 * @tc.number : HEVC_HW_HDR2SDR_STATE_1400
387 * @tc.name : create-configure-start-stop-reset-surface
388 * @tc.desc : function test
389 */
390 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1400, TestSize.Level2)
391 {
392 vDecSample2->SF_OUTPUT = true;
393 int32_t ret = vDecSample2->DecodeSetSurface();
394 ASSERT_EQ(AV_ERR_OK, ret);
395 ret = vDecSample2->Prepare();
396 ASSERT_EQ(AV_ERR_OK, ret);
397 ret = vDecSample2->Start();
398 ASSERT_EQ(AV_ERR_OK, ret);
399 ret = vDecSample2->Stop();
400 ASSERT_EQ(AV_ERR_OK, ret);
401 ret = vDecSample2->Reset();
402 ASSERT_EQ(AV_ERR_OK, ret);
403 }
404
405 /**
406 * @tc.number : HEVC_HW_HDR2SDR_STATE_1500
407 * @tc.name : create-configure-start-stop-error-surface
408 * @tc.desc : function test
409 */
410 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1500, TestSize.Level2)
411 {
412 vDecSample2->SF_OUTPUT = true;
413 int32_t ret = vDecSample2->DecodeSetSurface();
414 ASSERT_EQ(AV_ERR_OK, ret);
415 ret = vDecSample2->Prepare();
416 ASSERT_EQ(AV_ERR_OK, ret);
417 ret = vDecSample2->Start();
418 ASSERT_EQ(AV_ERR_OK, ret);
419 ret = vDecSample2->Stop();
420 ASSERT_EQ(AV_ERR_OK, ret);
421 ret = vDecSample2->Flush();
422 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
423 ret = vDecSample2->SetVideoDecoderCallback();
424 ASSERT_EQ(AV_ERR_OK, ret);
425 }
426
427 /**
428 * @tc.number : HEVC_HW_HDR2SDR_STATE_1600
429 * @tc.name : create-configure-start-EOS-reset-error-surface
430 * @tc.desc : function test
431 */
432 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1600, TestSize.Level2)
433 {
434 vDecSample2->SF_OUTPUT = true;
435 int32_t ret = vDecSample2->DecodeSetSurface();
436 ASSERT_EQ(AV_ERR_OK, ret);
437 ret = vDecSample2->StartVideoDecoder();
438 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
439 vDecSample2->WaitForEOS();
440 ASSERT_EQ(AV_ERR_OK, ret);
441 ASSERT_EQ(0, vDecSample2->errCount);
442 ret = vDecSample2->Reset();
443 ASSERT_EQ(AV_ERR_OK, ret);
444 ret = vDecSample2->Start();
445 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
446 ret = vDecSample2->Stop();
447 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
448 ret = vDecSample2->Flush();
449 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
450 }
451
452 /**
453 * @tc.number : HEVC_HW_HDR2SDR_STATE_1700
454 * @tc.name : create-configure-start-flush-start-flush-surface
455 * @tc.desc : function test
456 */
457 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1700, TestSize.Level2)
458 {
459 vDecSample2->SF_OUTPUT = true;
460 int32_t ret = vDecSample2->DecodeSetSurface();
461 ASSERT_EQ(AV_ERR_OK, ret);
462 ret = vDecSample2->Prepare();
463 ASSERT_EQ(AV_ERR_OK, ret);
464 ret = vDecSample2->Start();
465 ASSERT_EQ(AV_ERR_OK, ret);
466 ret = vDecSample2->Flush();
467 ASSERT_EQ(AV_ERR_OK, ret);
468 ret = vDecSample2->Start();
469 ASSERT_EQ(AV_ERR_OK, ret);
470 ret = vDecSample2->Flush();
471 ASSERT_EQ(AV_ERR_OK, ret);
472 }
473
474 /**
475 * @tc.number : HEVC_HW_HDR2SDR_STATE_1800
476 * @tc.name : create-configure-start-flush-start-eos-surface
477 * @tc.desc : function test
478 */
479 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1800, TestSize.Level2)
480 {
481 vDecSample2->SF_OUTPUT = true;
482 int32_t ret = vDecSample2->DecodeSetSurface();
483 ASSERT_EQ(AV_ERR_OK, ret);
484 ret = vDecSample2->Prepare();
485 ASSERT_EQ(AV_ERR_OK, ret);
486 ret = vDecSample2->Start();
487 ASSERT_EQ(AV_ERR_OK, ret);
488 ret = vDecSample2->Flush();
489 ASSERT_EQ(AV_ERR_OK, ret);
490 ret = vDecSample2->Start();
491 ASSERT_EQ(AV_ERR_OK, ret);
492 ret = vDecSample2->state_EOS();
493 ASSERT_EQ(AV_ERR_OK, ret);
494 }
495
496 /**
497 * @tc.number : HEVC_HW_HDR2SDR_STATE_1900
498 * @tc.name : create-configure-start-flush-start-stop-surface
499 * @tc.desc : function test
500 */
501 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_1900, TestSize.Level2)
502 {
503 vDecSample2->SF_OUTPUT = true;
504 int32_t ret = vDecSample2->DecodeSetSurface();
505 ASSERT_EQ(AV_ERR_OK, ret);
506 ret = vDecSample2->Prepare();
507 ASSERT_EQ(AV_ERR_OK, ret);
508 ret = vDecSample2->Start();
509 ASSERT_EQ(AV_ERR_OK, ret);
510 ret = vDecSample2->Flush();
511 ASSERT_EQ(AV_ERR_OK, ret);
512 ret = vDecSample2->Start();
513 ASSERT_EQ(AV_ERR_OK, ret);
514 ret = vDecSample2->Stop();
515 ASSERT_EQ(AV_ERR_OK, ret);
516 }
517
518 /**
519 * @tc.number : HEVC_HW_HDR2SDR_STATE_2000
520 * @tc.name : create-configure-start-flush-start-reset-surface
521 * @tc.desc : function test
522 */
523 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2000, TestSize.Level2)
524 {
525 vDecSample2->SF_OUTPUT = true;
526 int32_t ret = vDecSample2->DecodeSetSurface();
527 ASSERT_EQ(AV_ERR_OK, ret);
528 ret = vDecSample2->Prepare();
529 ASSERT_EQ(AV_ERR_OK, ret);
530 ret = vDecSample2->Start();
531 ASSERT_EQ(AV_ERR_OK, ret);
532 ret = vDecSample2->Flush();
533 ASSERT_EQ(AV_ERR_OK, ret);
534 ret = vDecSample2->Start();
535 ASSERT_EQ(AV_ERR_OK, ret);
536 ret = vDecSample2->Reset();
537 ASSERT_EQ(AV_ERR_OK, ret);
538 }
539
540 /**
541 * @tc.number : HEVC_HW_HDR2SDR_STATE_2100
542 * @tc.name : create-configure-start-flush-start-error-surface
543 * @tc.desc : function test
544 */
545 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2100, TestSize.Level2)
546 {
547 vDecSample2->SF_OUTPUT = true;
548 int32_t ret = vDecSample2->DecodeSetSurface();
549 ASSERT_EQ(AV_ERR_OK, ret);
550 ret = vDecSample2->Prepare();
551 ASSERT_EQ(AV_ERR_OK, ret);
552 ret = vDecSample2->Start();
553 ASSERT_EQ(AV_ERR_OK, ret);
554 ret = vDecSample2->Flush();
555 ASSERT_EQ(AV_ERR_OK, ret);
556 ret = vDecSample2->Start();
557 ASSERT_EQ(AV_ERR_OK, ret);
558 ret = vDecSample2->ConfigureVideoDecoder();
559 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
560 ret = vDecSample2->SetVideoDecoderCallback();
561 ASSERT_EQ(AV_ERR_OK, ret);
562 ret = vDecSample2->Release();
563 ASSERT_EQ(AV_ERR_OK, ret);
564 }
565
566 /**
567 * @tc.number : HEVC_HW_HDR2SDR_STATE_2200
568 * @tc.name : create-configure-start-flush-start-error-surface
569 * @tc.desc : function test
570 */
571 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2200, TestSize.Level2)
572 {
573 vDecSample2->SF_OUTPUT = true;
574 int32_t ret = vDecSample2->DecodeSetSurface();
575 ASSERT_EQ(AV_ERR_OK, ret);
576 ret = vDecSample2->Prepare();
577 ASSERT_EQ(AV_ERR_OK, ret);
578 ret = vDecSample2->Start();
579 ASSERT_EQ(AV_ERR_OK, ret);
580 ret = vDecSample2->Flush();
581 ASSERT_EQ(AV_ERR_OK, ret);
582 ret = vDecSample2->Stop();
583 ASSERT_EQ(AV_ERR_OK, ret);
584 ret = vDecSample2->Start();
585 ASSERT_EQ(AV_ERR_OK, ret);
586 cout << "set callback" << endl;
587 ret = vDecSample2->SetVideoDecoderCallback();
588 ASSERT_EQ(AV_ERR_OK, ret);
589 }
590
591 /**
592 * @tc.number : HEVC_HW_HDR2SDR_STATE_2300
593 * @tc.name : create-configure-start-flush-stop-start-surface
594 * @tc.desc : function test
595 */
596 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2300, TestSize.Level2)
597 {
598 vDecSample2->SF_OUTPUT = true;
599 int32_t ret = vDecSample2->DecodeSetSurface();
600 ASSERT_EQ(AV_ERR_OK, ret);
601 ret = vDecSample2->Prepare();
602 ASSERT_EQ(AV_ERR_OK, ret);
603 ret = vDecSample2->Start();
604 ASSERT_EQ(AV_ERR_OK, ret);
605 ret = vDecSample2->Flush();
606 ASSERT_EQ(AV_ERR_OK, ret);
607 ret = vDecSample2->Stop();
608 ASSERT_EQ(AV_ERR_OK, ret);
609 ret = vDecSample2->Release();
610 ASSERT_EQ(AV_ERR_OK, ret);
611 }
612
613 /**
614 * @tc.number : HEVC_HW_HDR2SDR_STATE_2400
615 * @tc.name : create-configure-start-flush-stop-reset-surface
616 * @tc.desc : function test
617 */
618 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2400, TestSize.Level2)
619 {
620 vDecSample2->SF_OUTPUT = true;
621 int32_t ret = vDecSample2->DecodeSetSurface();
622 ASSERT_EQ(AV_ERR_OK, ret);
623 ret = vDecSample2->Prepare();
624 ASSERT_EQ(AV_ERR_OK, ret);
625 ret = vDecSample2->Start();
626 ASSERT_EQ(AV_ERR_OK, ret);
627 ret = vDecSample2->Flush();
628 ASSERT_EQ(AV_ERR_OK, ret);
629 ret = vDecSample2->Stop();
630 ASSERT_EQ(AV_ERR_OK, ret);
631 ret = vDecSample2->Reset();
632 ASSERT_EQ(AV_ERR_OK, ret);
633 }
634
635 /**
636 * @tc.number : HEVC_HW_HDR2SDR_STATE_2500
637 * @tc.name : create-configure-start-flush-stop-error-surface
638 * @tc.desc : function test
639 */
640 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2500, TestSize.Level2)
641 {
642 vDecSample2->SF_OUTPUT = true;
643 int32_t ret = vDecSample2->DecodeSetSurface();
644 ASSERT_EQ(AV_ERR_OK, ret);
645 ret = vDecSample2->Prepare();
646 ASSERT_EQ(AV_ERR_OK, ret);
647 ret = vDecSample2->Start();
648 ASSERT_EQ(AV_ERR_OK, ret);
649 ret = vDecSample2->Flush();
650 ASSERT_EQ(AV_ERR_OK, ret);
651 ret = vDecSample2->Stop();
652 ASSERT_EQ(AV_ERR_OK, ret);
653 ret = vDecSample2->Flush();
654 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
655 ret = vDecSample2->SetVideoDecoderCallback();
656 ASSERT_EQ(AV_ERR_OK, ret);
657 }
658
659 /**
660 * @tc.number : HEVC_HW_HDR2SDR_STATE_2600
661 * @tc.name : create-configure-start-flush-reset-configure-surface
662 * @tc.desc : function test
663 */
664 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2600, TestSize.Level2)
665 {
666 vDecSample2->SF_OUTPUT = true;
667 int32_t ret = vDecSample2->DecodeSetSurface();
668 ASSERT_EQ(AV_ERR_OK, ret);
669 ret = vDecSample2->Prepare();
670 ASSERT_EQ(AV_ERR_OK, ret);
671 ret = vDecSample2->Start();
672 ASSERT_EQ(AV_ERR_OK, ret);
673 ret = vDecSample2->Flush();
674 ASSERT_EQ(AV_ERR_OK, ret);
675 ret = vDecSample2->Reset();
676 ASSERT_EQ(AV_ERR_OK, ret);
677 ret = vDecSample2->ConfigureVideoDecoder();
678 ASSERT_EQ(AV_ERR_OK, ret);
679 }
680
681 /**
682 * @tc.number : HEVC_HW_HDR2SDR_STATE_2700
683 * @tc.name : create-configure-start-flush-reset-release-surface
684 * @tc.desc : function test
685 */
686 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2700, TestSize.Level2)
687 {
688 vDecSample2->SF_OUTPUT = true;
689 int32_t ret = vDecSample2->DecodeSetSurface();
690 ASSERT_EQ(AV_ERR_OK, ret);
691 ret = vDecSample2->Prepare();
692 ASSERT_EQ(AV_ERR_OK, ret);
693 ret = vDecSample2->Start();
694 ASSERT_EQ(AV_ERR_OK, ret);
695 ret = vDecSample2->Flush();
696 ASSERT_EQ(AV_ERR_OK, ret);
697 ret = vDecSample2->Reset();
698 ASSERT_EQ(AV_ERR_OK, ret);
699 ret = vDecSample2->Release();
700 ASSERT_EQ(AV_ERR_OK, ret);
701 }
702
703 /**
704 * @tc.number : HEVC_HW_HDR2SDR_STATE_2800
705 * @tc.name : create-configure-start-flush-reset-error-surface
706 * @tc.desc : function test
707 */
708 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2800, TestSize.Level2)
709 {
710 vDecSample2->SF_OUTPUT = true;
711 int32_t ret = vDecSample2->DecodeSetSurface();
712 ASSERT_EQ(AV_ERR_OK, ret);
713 ret = vDecSample2->Prepare();
714 ASSERT_EQ(AV_ERR_OK, ret);
715 ret = vDecSample2->Start();
716 ASSERT_EQ(AV_ERR_OK, ret);
717 ret = vDecSample2->Flush();
718 ASSERT_EQ(AV_ERR_OK, ret);
719 ret = vDecSample2->Reset();
720 ASSERT_EQ(AV_ERR_OK, ret);
721 ret = vDecSample2->Start();
722 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
723 ret = vDecSample2->Stop();
724 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
725 ret = vDecSample2->Flush();
726 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
727 ret = vDecSample2->SetVideoDecoderCallback();
728 ASSERT_EQ(AV_ERR_OK, ret);
729 }
730
731 /**
732 * @tc.number : HEVC_HW_HDR2SDR_STATE_2900
733 * @tc.name : create-configure-start-reset-configure-surface
734 * @tc.desc : function test
735 */
736 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_2900, TestSize.Level2)
737 {
738 vDecSample2->SF_OUTPUT = true;
739 int32_t ret = vDecSample2->DecodeSetSurface();
740 ASSERT_EQ(AV_ERR_OK, ret);
741 ret = vDecSample2->Prepare();
742 ASSERT_EQ(AV_ERR_OK, ret);
743 ret = vDecSample2->Start();
744 ASSERT_EQ(AV_ERR_OK, ret);
745 ret = vDecSample2->Reset();
746 ASSERT_EQ(AV_ERR_OK, ret);
747 ret = vDecSample2->ConfigureVideoDecoder();
748 ASSERT_EQ(AV_ERR_OK, ret);
749 }
750
751 /**
752 * @tc.number : HEVC_HW_HDR2SDR_STATE_3000
753 * @tc.name : create-configure-start-reset-release-surface
754 * @tc.desc : function test
755 */
756 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3000, TestSize.Level2)
757 {
758 vDecSample2->SF_OUTPUT = true;
759 int32_t ret = vDecSample2->DecodeSetSurface();
760 ASSERT_EQ(AV_ERR_OK, ret);
761 ret = vDecSample2->Prepare();
762 ASSERT_EQ(AV_ERR_OK, ret);
763 ret = vDecSample2->Start();
764 ASSERT_EQ(AV_ERR_OK, ret);
765 ret = vDecSample2->Reset();
766 ASSERT_EQ(AV_ERR_OK, ret);
767 ret = vDecSample2->Release();
768 ASSERT_EQ(AV_ERR_OK, ret);
769 }
770
771 /**
772 * @tc.number : HEVC_HW_HDR2SDR_STATE_3100
773 * @tc.name : create-configure-start-reset-error-surface
774 * @tc.desc : function test
775 */
776 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3100, TestSize.Level2)
777 {
778 vDecSample2->SF_OUTPUT = true;
779 int32_t ret = vDecSample2->DecodeSetSurface();
780 ASSERT_EQ(AV_ERR_OK, ret);
781 ret = vDecSample2->Prepare();
782 ASSERT_EQ(AV_ERR_OK, ret);
783 ret = vDecSample2->Start();
784 ASSERT_EQ(AV_ERR_OK, ret);
785 ret = vDecSample2->Reset();
786 ASSERT_EQ(AV_ERR_OK, ret);
787 ret = vDecSample2->Start();
788 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
789 ret = vDecSample2->Stop();
790 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
791 ret = vDecSample2->Flush();
792 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
793 ret = vDecSample2->SetVideoDecoderCallback();
794 ASSERT_EQ(AV_ERR_OK, ret);
795 }
796
797 /**
798 * @tc.number : HEVC_HW_HDR2SDR_STATE_3200
799 * @tc.name : create-configure-start-error-surface
800 * @tc.desc : function test
801 */
802 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3200, TestSize.Level2)
803 {
804 vDecSample2->SF_OUTPUT = true;
805 int32_t ret = vDecSample2->DecodeSetSurface();
806 ASSERT_EQ(AV_ERR_OK, ret);
807 ret = vDecSample2->Prepare();
808 ASSERT_EQ(AV_ERR_OK, ret);
809 ret = vDecSample2->Start();
810 ASSERT_EQ(AV_ERR_OK, ret);
811 ret = vDecSample2->ConfigureVideoDecoder();
812 ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
813 ret = vDecSample2->SetVideoDecoderCallback();
814 ASSERT_EQ(AV_ERR_OK, ret);
815 ret = vDecSample2->Release();
816 ASSERT_EQ(AV_ERR_OK, ret);
817 }
818
819 /**
820 * @tc.number : HEVC_HW_HDR2SDR_STATE_3300
821 * @tc.name : create-configure-reset-configure-surface
822 * @tc.desc : function test
823 */
824 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3300, TestSize.Level2)
825 {
826 vDecSample2->SF_OUTPUT = true;
827 int32_t ret = vDecSample2->DecodeSetSurface();
828 ASSERT_EQ(AV_ERR_OK, ret);
829 ret = vDecSample2->Reset();
830 ASSERT_EQ(AV_ERR_OK, ret);
831 ret = vDecSample2->ConfigureVideoDecoder();
832 ASSERT_EQ(AV_ERR_OK, ret);
833 }
834
835 /**
836 * @tc.number : HEVC_HW_HDR2SDR_STATE_3400
837 * @tc.name : create-configure-release-surface
838 * @tc.desc : function test
839 */
840 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3400, TestSize.Level2)
841 {
842 vDecSample2->SF_OUTPUT = true;
843 int32_t ret = vDecSample2->DecodeSetSurface();
844 ASSERT_EQ(AV_ERR_OK, ret);
845 ret = vDecSample2->Release();
846 ASSERT_EQ(AV_ERR_OK, ret);
847 }
848
849 /**
850 * @tc.number : HEVC_HW_HDR2SDR_STATE_3500
851 * @tc.name : Flush or stop in buffe decoder callback function-surface
852 * @tc.desc : function test
853 */
854 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3500, TestSize.Level1)
855 {
856 vDecSample2->SF_OUTPUT = true;
857 int32_t ret = vDecSample2->DecodeSetSurface();
858 ASSERT_EQ(AV_ERR_OK, ret);
859 vDecSample2->inputCallbackFlush = true;
860 ret = vDecSample2->StartVideoDecoder();
861 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
862 vDecSample2->WaitForEOS();
863 ASSERT_EQ(AV_ERR_OK, ret);
864 }
865
866 /**
867 * @tc.number : HEVC_HW_HDR2SDR_STATE_3600
868 * @tc.name : Flush or stop in buffe decoder callback function-surface
869 * @tc.desc : function test
870 */
871 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3600, TestSize.Level1)
872 {
873 vDecSample2->SF_OUTPUT = true;
874 int32_t ret = vDecSample2->DecodeSetSurface();
875 ASSERT_EQ(AV_ERR_OK, ret);
876 vDecSample2->inputCallbackStop = true;
877 ret = vDecSample2->StartVideoDecoder();
878 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
879 ASSERT_EQ(AV_ERR_OK, ret);
880 vDecSample2->WaitForEOS();
881 }
882
883 /**
884 * @tc.number : HEVC_HW_HDR2SDR_STATE_3700
885 * @tc.name : Flush or stop in buffe decoder callback function-surface
886 * @tc.desc : function test
887 */
888 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3700, TestSize.Level1)
889 {
890 vDecSample2->SF_OUTPUT = true;
891 int32_t ret = vDecSample2->DecodeSetSurface();
892 ASSERT_EQ(AV_ERR_OK, ret);
893 vDecSample2->outputCallbackFlush = true;
894 ret = vDecSample2->StartVideoDecoder();
895 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
896 ASSERT_EQ(AV_ERR_OK, ret);
897 vDecSample2->WaitForEOS();
898 }
899
900 /**
901 * @tc.number : HEVC_HW_HDR2SDR_STATE_3800
902 * @tc.name : Flush or stop in buffe decoder callback function-surface
903 * @tc.desc : function test
904 */
905 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3800, TestSize.Level1)
906 {
907 vDecSample2->SF_OUTPUT = true;
908 int32_t ret = vDecSample2->DecodeSetSurface();
909 ASSERT_EQ(AV_ERR_OK, ret);
910 vDecSample2->outputCallbackStop = true;
911 ret = vDecSample2->StartVideoDecoder();
912 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
913 ASSERT_EQ(AV_ERR_OK, ret);
914 vDecSample2->WaitForEOS();
915 }
916
917 /**
918 * @tc.number : HEVC_HW_HDR2SDR_STATE_3900
919 * @tc.name : Flush or stop in surf decoder callback function-surface
920 * @tc.desc : function test
921 */
922 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_3900, TestSize.Level1)
923 {
924 vDecSample2->SF_OUTPUT = true;
925 int32_t ret = vDecSample2->DecodeSetSurface();
926 ASSERT_EQ(AV_ERR_OK, ret);
927 vDecSample2->SF_OUTPUT = true;
928 vDecSample2->inputCallbackFlush = true;
929 ret = vDecSample2->StartVideoDecoder();
930 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
931 vDecSample2->WaitForEOS();
932 ASSERT_EQ(AV_ERR_OK, ret);
933 }
934
935 /**
936 * @tc.number : HEVC_HW_HDR2SDR_STATE_4000
937 * @tc.name : Flush or stop in buffe decoder callback function-surface
938 * @tc.desc : function test
939 */
940 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4000, TestSize.Level1)
941 {
942 vDecSample2->SF_OUTPUT = true;
943 int32_t ret = vDecSample2->DecodeSetSurface();
944 ASSERT_EQ(AV_ERR_OK, ret);
945 vDecSample2->SF_OUTPUT = true;
946 vDecSample2->inputCallbackStop = true;
947 ret = vDecSample2->StartVideoDecoder();
948 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
949 ASSERT_EQ(AV_ERR_OK, ret);
950 vDecSample2->WaitForEOS();
951 }
952
953 /**
954 * @tc.number : HEVC_HW_HDR2SDR_STATE_4100
955 * @tc.name : Flush or stop in buffe decoder callback function-surface
956 * @tc.desc : function test
957 */
958 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4100, TestSize.Level1)
959 {
960 vDecSample2->SF_OUTPUT = true;
961 int32_t ret = vDecSample2->DecodeSetSurface();
962 ASSERT_EQ(AV_ERR_OK, ret);
963 vDecSample2->SF_OUTPUT = true;
964 vDecSample2->outputCallbackFlush = true;
965 ret = vDecSample2->StartVideoDecoder();
966 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
967 ASSERT_EQ(AV_ERR_OK, ret);
968 vDecSample2->WaitForEOS();
969 }
970
971 /**
972 * @tc.number : HEVC_HW_HDR2SDR_STATE_4200
973 * @tc.name : Flush or stop in buffe decoder callback function-surface
974 * @tc.desc : function test
975 */
976 HWTEST_F(HwdecHdr2SdrStateNdkTest, HEVC_HW_HDR2SDR_STATE_4200, TestSize.Level1)
977 {
978 vDecSample2->SF_OUTPUT = true;
979 int32_t ret = vDecSample2->DecodeSetSurface();
980 ASSERT_EQ(AV_ERR_OK, ret);
981 vDecSample2->SF_OUTPUT = true;
982 vDecSample2->outputCallbackStop = true;
983 ret = vDecSample2->StartVideoDecoder();
984 vDecSample2->AFTER_EOS_DESTORY_CODEC = false;
985 ASSERT_EQ(AV_ERR_OK, ret);
986 vDecSample2->WaitForEOS();
987 }
988 } //namespace