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_avcodec_videoencoder.h"
19 #include "native_averrors.h"
20 #include "videodec_api11_sample.h"
21 #include "native_avcodec_base.h"
22 #include "avcodec_codec_name.h"
23 #include "native_avcapability.h"
24 #include "native_buffer.h"
25 
26 #define MAX_THREAD 16
27 
28 using namespace std;
29 using namespace OHOS;
30 using namespace OHOS::Media;
31 using namespace testing::ext;
32 
33 namespace OHOS {
34 namespace Media {
35 class HwdecHdr2SdrNdkTest : public testing::Test {
36 public:
37     static void SetUpTestCase();
38     static void TearDownTestCase();
39     void SetUp() override;
40     void TearDown() override;
41     void InputFunc();
42     void OutputFunc();
43     void Release();
44     int32_t Stop();
45 };
46 } // namespace Media
47 } // namespace OHOS
48 
49 namespace {
50 static OH_AVCapability *cap_avc = nullptr;
51 static OH_AVCapability *cap_hevc = nullptr;
52 static string g_codecNameAVC = "";
53 static string g_codecNameHEVC = "";
54 OH_AVCodec *vdec_ = NULL;
55 OH_AVFormat *format;
56 constexpr int32_t DEFAULT_WIDTH = 1920;
57 constexpr int32_t DEFAULT_HEIGHT = 1080;
58 } // namespace
59 
SetUpTestCase()60 void HwdecHdr2SdrNdkTest::SetUpTestCase()
61 {
62     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
63     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
64     cout << "g_codecNameHEVC: " << g_codecNameHEVC << endl;
65 }
TearDownTestCase()66 void HwdecHdr2SdrNdkTest::TearDownTestCase() {}
67 
SetUp(void)68 void HwdecHdr2SdrNdkTest::SetUp(void) {}
69 
TearDown()70 void HwdecHdr2SdrNdkTest::TearDown()
71 {
72     if (format != nullptr) {
73         OH_AVFormat_Destroy(format);
74         format = nullptr;
75     }
76     if (vdec_ != NULL) {
77         OH_VideoDecoder_Destroy(vdec_);
78         vdec_ = nullptr;
79     }
80 }
81 
82 namespace {
83 /**
84  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_001
85  * @tc.name      : OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE设置为BT_709_FULL
86  * @tc.desc      : function test
87  */
88 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_001, TestSize.Level2)
89 {
90     if (!access("/system/lib64/media/", 0)) {
91         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
92         ASSERT_NE(NULL, vdec_);
93         format = OH_AVFormat_Create();
94         ASSERT_NE(NULL, format);
95         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
96         OH_COLORSPACE_BT709_FULL));
97         ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
98     }
99     else {
100         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
101         ASSERT_NE(NULL, vdec_);
102         format = OH_AVFormat_Create();
103         ASSERT_NE(NULL, format);
104         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
105         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
106         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
107         OH_COLORSPACE_BT709_FULL));
108         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, OH_VideoDecoder_Configure(vdec_, format));
109     }
110 }
111 
112 /**
113  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_002
114  * @tc.name      : OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE设置为BT_709_LIMIT, pixel foramt RGBA
115  * @tc.desc      : function test
116  */
117 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_002, TestSize.Level2)
118 {
119     if (!access("/system/lib64/media/", 0)) {
120         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
121         ASSERT_NE(NULL, vdec_);
122         format = OH_AVFormat_Create();
123         ASSERT_NE(NULL, format);
124         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
125         OH_COLORSPACE_BT709_LIMIT));
126         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA));
127         ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
128     }
129     else {
130         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
131         ASSERT_NE(NULL, vdec_);
132         format = OH_AVFormat_Create();
133         ASSERT_NE(NULL, format);
134         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
135         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
136         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
137         OH_COLORSPACE_BT709_LIMIT));
138         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_PIXEL_FORMAT, AV_PIXEL_FORMAT_RGBA));
139         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, OH_VideoDecoder_Configure(vdec_, format));
140     }
141 }
142 
143 
144 /**
145  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_003
146  * @tc.name      : OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE设置为BT_2020_LIMIT
147  * @tc.desc      : function test
148  */
149 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_003, TestSize.Level2)
150 {
151     if (!access("/system/lib64/media/", 0)) {
152         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
153         ASSERT_NE(NULL, vdec_);
154         format = OH_AVFormat_Create();
155         ASSERT_NE(NULL, format);
156         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
157         OH_COLORSPACE_BT2020_HLG_LIMIT));
158         ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
159     }
160     else {
161         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
162         ASSERT_NE(NULL, vdec_);
163         format = OH_AVFormat_Create();
164         ASSERT_NE(NULL, format);
165         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
166         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
167         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
168         OH_COLORSPACE_BT2020_HLG_LIMIT));
169         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, OH_VideoDecoder_Configure(vdec_, format));
170     }
171 }
172 
173 /**
174  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_0032
175  * @tc.name      : OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE设置为BT_709_LIMIT
176  * @tc.desc      : function test
177  */
178 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_0032, TestSize.Level2)
179 {
180     if (!access("/system/lib64/media/", 0)) {
181         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
182         ASSERT_NE(NULL, vdec_);
183         format = OH_AVFormat_Create();
184         ASSERT_NE(NULL, format);
185         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
186         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
187         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
188         OH_COLORSPACE_BT709_LIMIT));
189         ASSERT_EQ(AV_ERR_OK, OH_VideoDecoder_Configure(vdec_, format));
190     }
191     else {
192         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
193         ASSERT_NE(NULL, vdec_);
194         format = OH_AVFormat_Create();
195         ASSERT_NE(NULL, format);
196         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
197         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
198         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
199         OH_COLORSPACE_BT709_LIMIT));
200         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, OH_VideoDecoder_Configure(vdec_, format));
201     }
202 }
203 
204 /**
205  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_004
206  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, SDR
207  * @tc.desc      : function test
208  */
209 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_004, TestSize.Level2)
210 
211 {
212     if (!access("/system/lib64/media/", 0)) {
213         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
214         vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
215         vDecSample->SF_OUTPUT = true;
216         vDecSample->TRANSFER_FLAG = true;
217         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
218         vDecSample->WaitForEOS();
219         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
220     }
221     else {
222         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
223         vDecSample->INP_DIR = "/data/test/media/1920_1080_20M_30.h265";
224         vDecSample->SF_OUTPUT = true;
225         vDecSample->TRANSFER_FLAG = true;
226         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
227         vDecSample->WaitForEOS();
228         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
229     }
230 }
231 
232 /**
233  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_005
234  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, HDR 10
235  * @tc.desc      : function test
236  */
237 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_005, TestSize.Level2)
238 {
239     if (!access("/system/lib64/media/", 0)) {
240         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
241         vDecSample->INP_DIR = "/data/test/media/hdr10.h265";
242         vDecSample->SF_OUTPUT = true;
243         vDecSample->TRANSFER_FLAG = true;
244         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
245         vDecSample->WaitForEOS();
246         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
247     }
248     else {
249         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
250         vDecSample->INP_DIR = "/data/test/media/hdr10.h265";
251         vDecSample->SF_OUTPUT = true;
252         vDecSample->TRANSFER_FLAG = true;
253         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
254         vDecSample->WaitForEOS();
255         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
256     }
257 }
258 
259 /**
260  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_006
261  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, HLG
262  * @tc.desc      : function test
263  */
264 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_006, TestSize.Level2)
265 {
266     if (!access("/system/lib64/media/", 0)) {
267         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
268         vDecSample->INP_DIR = "/data/test/media/hlg.h265";
269         vDecSample->SF_OUTPUT = true;
270         vDecSample->TRANSFER_FLAG = true;
271         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
272         vDecSample->WaitForEOS();
273         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
274     }
275     else {
276         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
277         vDecSample->INP_DIR = "/data/test/media/hlg.h265";
278         vDecSample->SF_OUTPUT = true;
279         vDecSample->TRANSFER_FLAG = true;
280         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
281         vDecSample->WaitForEOS();
282         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
283     }
284 }
285 
286 /**
287  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_0061
288  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, 4k_720p_1080p
289  * @tc.desc      : function test
290  */
291 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_0061, TestSize.Level2)
292 {
293     if (!access("/system/lib64/media/", 0)) {
294         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
295         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k_720p_1080p.h265";
296         vDecSample->DEFAULT_WIDTH = 3840;
297         vDecSample->DEFAULT_HEIGHT = 2160;
298         vDecSample->SF_OUTPUT = true;
299         vDecSample->TRANSFER_FLAG = true;
300         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
301         vDecSample->WaitForEOS();
302         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
303     }
304     else {
305         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
306         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k_720p_1080p.h265";
307         vDecSample->DEFAULT_WIDTH = 3840;
308         vDecSample->DEFAULT_HEIGHT = 2160;
309         vDecSample->SF_OUTPUT = true;
310         vDecSample->TRANSFER_FLAG = true;
311         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
312         vDecSample->WaitForEOS();
313         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
314     }
315 }
316 
317 /**
318  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_007
319  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, PQ HDR vivid
320  * @tc.desc      : function test
321  */
322 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_007, TestSize.Level2)
323 {
324     if (!access("/system/lib64/media/", 0)) {
325         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
326         vDecSample->INP_DIR = "/data/test/media/pqHdrVivid_4k.h265";
327         vDecSample->DEFAULT_WIDTH = 3840;
328         vDecSample->DEFAULT_HEIGHT = 2160;
329         vDecSample->SF_OUTPUT = true;
330         vDecSample->TRANSFER_FLAG = true;
331         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
332         vDecSample->WaitForEOS();
333         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
334     }
335     else {
336         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
337         vDecSample->INP_DIR = "/data/test/media/pqHdrVivid_4k.h265";
338         vDecSample->DEFAULT_WIDTH = 3840;
339         vDecSample->DEFAULT_HEIGHT = 2160;
340         vDecSample->SF_OUTPUT = true;
341         vDecSample->TRANSFER_FLAG = true;
342         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
343         vDecSample->WaitForEOS();
344         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
345     }
346 }
347 
348 /**
349  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_008
350  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, HLG HDR vivid
351  * @tc.desc      : function test
352  */
353 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_008, TestSize.Level2)
354 {
355     if (!access("/system/lib64/media/", 0)) {
356         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
357         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k.h265";
358         vDecSample->DEFAULT_WIDTH = 3840;
359         vDecSample->DEFAULT_HEIGHT = 2160;
360         vDecSample->SF_OUTPUT = true;
361         vDecSample->TRANSFER_FLAG = true;
362         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
363         vDecSample->WaitForEOS();
364         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
365     }
366     else {
367         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
368         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k.h265";
369         vDecSample->DEFAULT_WIDTH = 3840;
370         vDecSample->DEFAULT_HEIGHT = 2160;
371         vDecSample->SF_OUTPUT = true;
372         vDecSample->TRANSFER_FLAG = true;
373         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
374         vDecSample->WaitForEOS();
375         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
376     }
377 }
378 
379 /**
380  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_009
381  * @tc.name      : test h265 hard decode surface, pixel foramt nv12, KEY设置为BT_709_LIMIT, HLG HDR vivid
382  * @tc.desc      : function test
383  */
384 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_009, TestSize.Level2)
385 {
386     if (!access("/system/lib64/media/", 0)) {
387         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
388         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
389         vDecSample->SF_OUTPUT = true;
390         vDecSample->TRANSFER_FLAG = true;
391         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
392         vDecSample->WaitForEOS();
393         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
394     }
395     else {
396         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
397         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
398         vDecSample->SF_OUTPUT = true;
399         vDecSample->TRANSFER_FLAG = true;
400         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
401         vDecSample->WaitForEOS();
402         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
403     }
404 }
405 
406 /**
407  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_010
408  * @tc.name      : test h265 hard decode surface, pixel foramt nv21, KEY设置为BT_709_LIMIT, PQ HDR vivid
409  * @tc.desc      : function test
410  */
411 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_010, TestSize.Level2)
412 {
413     if (!access("/system/lib64/media/", 0)) {
414         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
415         vDecSample->INP_DIR = "/data/test/media/pqHdrVivid_4k.h265";
416         vDecSample->DEFAULT_WIDTH = 3840;
417         vDecSample->DEFAULT_HEIGHT = 2160;
418         vDecSample->SF_OUTPUT = true;
419         vDecSample->TRANSFER_FLAG = true;
420         vDecSample->NV21_FLAG = true;
421         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
422         vDecSample->WaitForEOS();
423         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
424     }
425     else {
426         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
427         vDecSample->INP_DIR = "/data/test/media/pqHdrVivid_4k.h265";
428         vDecSample->DEFAULT_WIDTH = 3840;
429         vDecSample->DEFAULT_HEIGHT = 2160;
430         vDecSample->SF_OUTPUT = true;
431         vDecSample->TRANSFER_FLAG = true;
432         vDecSample->NV21_FLAG = true;
433         ASSERT_EQ(AV_ERR_UNSUPPORT, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
434         vDecSample->WaitForEOS();
435         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
436     }
437 }
438 
439 /**
440  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_011
441  * @tc.name      : test h265 hard decode surface, pixel foramt nv21, KEY设置为BT_709_LIMIT, HLG HDR vivid
442  * @tc.desc      : function test
443  */
444 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_011, TestSize.Level2)
445 {
446     if (!access("/system/lib64/media/", 0)) {
447         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
448         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k.h265";
449         vDecSample->DEFAULT_WIDTH = 3840;
450         vDecSample->DEFAULT_HEIGHT = 2160;
451         vDecSample->SF_OUTPUT = true;
452         vDecSample->TRANSFER_FLAG = true;
453         vDecSample->NV21_FLAG = true;
454         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
455         vDecSample->WaitForEOS();
456         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
457     }
458     else {
459         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
460         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_4k.h265";
461         vDecSample->DEFAULT_WIDTH = 3840;
462         vDecSample->DEFAULT_HEIGHT = 2160;
463         vDecSample->SF_OUTPUT = true;
464         vDecSample->TRANSFER_FLAG = true;
465         vDecSample->NV21_FLAG = true;
466         ASSERT_EQ(AV_ERR_UNSUPPORT, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
467         vDecSample->WaitForEOS();
468         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
469     }
470 }
471 
472 /**
473  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_012
474  * @tc.name      : test h265 hard decode surface, pixel foramt nv21, KEY设置为BT_709_LIMIT, HLG HDR vivid
475  * @tc.desc      : function test
476  */
477 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_012, TestSize.Level2)
478 {
479     if (!access("/system/lib64/media/", 0)) {
480         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
481         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
482         vDecSample->SF_OUTPUT = true;
483         vDecSample->TRANSFER_FLAG = true;
484         vDecSample->NV21_FLAG = true;
485         ASSERT_EQ(AV_ERR_OK, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
486         vDecSample->WaitForEOS();
487         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
488     }
489     else {
490         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
491         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
492         vDecSample->SF_OUTPUT = true;
493         vDecSample->TRANSFER_FLAG = true;
494         vDecSample->NV21_FLAG = true;
495         ASSERT_EQ(AV_ERR_UNSUPPORT, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
496         vDecSample->WaitForEOS();
497         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
498     }
499 }
500 
501 /**
502  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_013
503  * @tc.name      : test h265 hard decode buffer, pixel foramt nv21, KEY设置为BT_709_LIMIT, HLG HDR vivid
504  * @tc.desc      : function test
505  */
506 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_013, TestSize.Level2)
507 {
508     if (!access("/system/lib64/media/", 0)) {
509         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
510         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
511         vDecSample->SF_OUTPUT = false;
512         vDecSample->TRANSFER_FLAG = true;
513         vDecSample->NV21_FLAG = true;
514         ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->RunVideoDec(g_codecNameHEVC));
515         vDecSample->WaitForEOS();
516         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
517     }
518     else {
519         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
520         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
521         vDecSample->SF_OUTPUT = false;
522         vDecSample->TRANSFER_FLAG = true;
523         vDecSample->NV21_FLAG = true;
524         ASSERT_EQ(AV_ERR_UNSUPPORT, vDecSample->RunVideoDec(g_codecNameHEVC));
525         vDecSample->WaitForEOS();
526         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
527     }
528 }
529 
530 /**
531  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_014
532  * @tc.name      : test h265 encoder set OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE to BT_709_LIMIT
533  * @tc.desc      : function test
534  */
535 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_014, TestSize.Level2)
536 {
537     cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, true, HARDWARE);
538     g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
539     vdec_ = OH_VideoEncoder_CreateByName(g_codecNameHEVC.c_str());
540     ASSERT_NE(NULL, vdec_);
541     format = OH_AVFormat_Create();
542     ASSERT_NE(NULL, format);
543     ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
544     ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
545     ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
546     OH_COLORSPACE_BT709_LIMIT));
547     ASSERT_EQ(AV_ERR_OK, OH_VideoEncoder_Configure(vdec_, format));
548 }
549 
550 /**
551  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_015
552  * @tc.name      : test h265 software decoder, KEY设置为BT_709_LIMIT
553  * @tc.desc      : function test
554  */
555 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_015, TestSize.Level2)
556 {
557     if (!access("/system/lib64/media/", 0)) {
558         cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, SOFTWARE);
559         g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
560         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameHEVC.c_str());
561         ASSERT_NE(NULL, vdec_);
562         format = OH_AVFormat_Create();
563         ASSERT_NE(NULL, format);
564         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
565         OH_COLORSPACE_BT709_LIMIT));
566         ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
567     }
568 }
569 
570 /**
571  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_016
572  * @tc.name      : test h264 hardware decoder, set OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE to BT_709_LIMIT
573  * @tc.desc      : function test
574  */
575 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_016, TestSize.Level2)
576 {
577     if (!access("/system/lib64/media/", 0)) {
578         cap_avc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
579         g_codecNameAVC = OH_AVCapability_GetName(cap_avc);
580         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameAVC.c_str());
581         ASSERT_NE(NULL, vdec_);
582         format = OH_AVFormat_Create();
583         ASSERT_NE(NULL, format);
584         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
585         OH_COLORSPACE_BT709_LIMIT));
586         ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
587     }
588     else {
589         cap_avc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, HARDWARE);
590         g_codecNameAVC = OH_AVCapability_GetName(cap_avc);
591         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameAVC.c_str());
592         ASSERT_NE(NULL, vdec_);
593         format = OH_AVFormat_Create();
594         ASSERT_NE(NULL, format);
595         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
596         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
597         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
598         OH_COLORSPACE_BT709_LIMIT));
599         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, OH_VideoDecoder_Configure(vdec_, format));
600     }
601 }
602 
603 /**
604  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_017
605  * @tc.name      : test h264 software decoder, set OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE to BT_709_LIMIT
606  * @tc.desc      : function test
607  */
608 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_017, TestSize.Level2)
609 {
610     if (!access("/system/lib64/media/", 0)) {
611         cap_avc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
612         g_codecNameAVC = OH_AVCapability_GetName(cap_avc);
613         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameAVC.c_str());
614         ASSERT_NE(NULL, vdec_);
615         format = OH_AVFormat_Create();
616         ASSERT_NE(NULL, format);
617         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
618         OH_COLORSPACE_BT709_LIMIT));
619         ASSERT_EQ(AV_ERR_INVALID_VAL, OH_VideoDecoder_Configure(vdec_, format));
620     }
621     else {
622         cap_avc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_AVC, false, SOFTWARE);
623         g_codecNameAVC = OH_AVCapability_GetName(cap_avc);
624         vdec_ = OH_VideoDecoder_CreateByName(g_codecNameAVC.c_str());
625         ASSERT_NE(NULL, vdec_);
626         format = OH_AVFormat_Create();
627         ASSERT_NE(NULL, format);
628         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_HEIGHT, DEFAULT_HEIGHT));
629         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_WIDTH, DEFAULT_WIDTH));
630         ASSERT_EQ(true, OH_AVFormat_SetIntValue(format, OH_MD_KEY_VIDEO_DECODER_OUTPUT_COLOR_SPACE,
631         OH_COLORSPACE_BT709_LIMIT));
632         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, OH_VideoDecoder_Configure(vdec_, format));
633     }
634 }
635 
636 /**
637  * @tc.number    : HEVC_HW_HDR2SDR_FUNC_018
638  * @tc.name      : test h265 HDR2SDR, no prepare before start
639  * @tc.desc      : function test
640  */
641 HWTEST_F(HwdecHdr2SdrNdkTest, HEVC_HW_HDR2SDR_FUNC_018, TestSize.Level2)
642 {
643     if (!access("/system/lib64/media/", 0)) {
644         cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
645         g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
646         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
647         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
648         vDecSample->SF_OUTPUT = true;
649         vDecSample->TRANSFER_FLAG = true;
650         vDecSample->PREPARE_FLAG = false;
651         ASSERT_EQ(AV_ERR_OPERATE_NOT_PERMIT, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
652         vDecSample->WaitForEOS();
653         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
654     }
655     else {
656         cap_hevc = OH_AVCodec_GetCapabilityByCategory(OH_AVCODEC_MIMETYPE_VIDEO_HEVC, false, HARDWARE);
657         g_codecNameHEVC = OH_AVCapability_GetName(cap_hevc);
658         shared_ptr<VDecAPI11Sample> vDecSample = make_shared<VDecAPI11Sample>();
659         vDecSample->INP_DIR = "/data/test/media/hlgHdrVivid_1080p.h265";
660         vDecSample->SF_OUTPUT = true;
661         vDecSample->TRANSFER_FLAG = true;
662         vDecSample->PREPARE_FLAG = false;
663         ASSERT_EQ(AV_ERR_VIDEO_UNSUPPORTED_COLOR_SPACE_CONVERSION, vDecSample->RunVideoDec_Surface(g_codecNameHEVC));
664         vDecSample->WaitForEOS();
665         ASSERT_EQ(AV_ERR_OK, vDecSample->errCount);
666     }
667 }
668 } //namespace