1 /*
2 * Copyright (C) 2025 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 <iostream>
16 #include <chrono>
17 #include "gtest/gtest.h"
18 #include "video_processing.h"
19 #include "enum_list.h"
20 #include "video_sample.h"
21 using namespace std;
22 using namespace OHOS;
23 using namespace testing::ext;
24
25 namespace {
26 static uint32_t g_allTestCount = 0;
27 static uint32_t g_supportedCount = 0;
28 static uint32_t g_unsupportedCount = 0;
29 std::unique_ptr<std::ofstream> outputListFile = nullptr;
30
31 class VpeVideoReliTest : public testing::Test {
32 public:
33 // SetUpTestCase: Called before all test cases
34 static void SetUpTestCase(void);
35 // TearDownTestCase: Called after all test case
36 static void TearDownTestCase(void);
37 // SetUp: Called before each test cases
38 void SetUp(void);
39 // TearDown: Called after each test cases
40 void TearDown(void);
41 };
42
SetUpTestCase()43 void VpeVideoReliTest::SetUpTestCase()
44 {
45 OH_VideoProcessing_InitializeEnvironment();
46 }
TearDownTestCase()47 void VpeVideoReliTest::TearDownTestCase()
48 {
49 OH_VideoProcessing_DeinitializeEnvironment();
50 }
SetUp()51 void VpeVideoReliTest::SetUp()
52 {
53 g_allTestCount = 0;
54 g_supportedCount = 0;
55 g_unsupportedCount = 0;
56 }
TearDown()57 void VpeVideoReliTest::TearDown()
58 {
59 }
60 }
61 namespace {
62 #ifdef ENABLE_ALL_PROCESS
CheckHDRColorSpaceAndPixFmt(VideoProcessing_ColorSpaceInfo info,bool isHDR2SDR=false)63 static bool CheckHDRColorSpaceAndPixFmt(VideoProcessing_ColorSpaceInfo info, bool isHDR2SDR = false)
64 {
65 if ((info.metadataType == OH_VIDEO_HDR_HLG) && (info.colorSpace != OH_COLORSPACE_BT2020_HLG_LIMIT)) {
66 return false;
67 }
68 if ((info.metadataType == OH_VIDEO_HDR_HDR10) && (info.colorSpace != OH_COLORSPACE_BT2020_PQ_LIMIT)) {
69 return false;
70 }
71 if (!isHDR2SDR) {
72 switch (info.colorSpace) {
73 case OH_COLORSPACE_BT2020_HLG_LIMIT:
74 case OH_COLORSPACE_BT2020_PQ_LIMIT:
75 break;
76 default:
77 return false;
78 }
79 } else {
80 switch (info.colorSpace) {
81 case OH_COLORSPACE_BT2020_HLG_LIMIT:
82 case OH_COLORSPACE_BT2020_PQ_LIMIT:
83 case OH_COLORSPACE_BT2020_HLG_FULL:
84 break;
85 default:
86 return false;
87 }
88 }
89 switch (info.pixelFormat) {
90 case NATIVEBUFFER_PIXEL_FMT_YCBCR_P010:
91 case NATIVEBUFFER_PIXEL_FMT_YCRCB_P010:
92 case NATIVEBUFFER_PIXEL_FMT_RGBA_1010102:
93 return true;
94 default:
95 return false;
96 }
97 }
98
CheckSupportedMetadataGen(VideoProcessing_ColorSpaceInfo info)99 static bool CheckSupportedMetadataGen(VideoProcessing_ColorSpaceInfo info)
100 {
101 switch (info.metadataType) {
102 case OH_VIDEO_HDR_HLG:
103 case OH_VIDEO_HDR_HDR10:
104 case OH_VIDEO_HDR_VIVID:
105 break;
106 default:
107 return false;
108 }
109 return CheckHDRColorSpaceAndPixFmt(info);
110 }
111
BoolToString(bool val)112 static std::string BoolToString(bool val)
113 {
114 if (val) {
115 return "true";
116 }
117 return "false";
118 }
119
CheckMetadataGen(VideoProcessing_ColorSpaceInfo info)120 void CheckMetadataGen(VideoProcessing_ColorSpaceInfo info)
121 {
122 bool expectVal = CheckSupportedMetadataGen(info);
123 bool realVal = OH_VideoProcessing_IsMetadataGenerationSupported(&info);
124 if (expectVal != realVal) {
125 string msg = "-----------------------------------------------\n";
126 msg += "metadata gen type:" + metadataString[info.metadataType] + "\n";
127 msg += "colorspace:" + colorString[info.colorSpace] + "\n";
128 msg += "format:" + formatString[info.pixelFormat] + "\n";
129 msg += "expect" + BoolToString(expectVal) + " actual:" + BoolToString(realVal) + "\n";
130 msg += "-----------------------------------------------\n";
131 outputListFile->write(msg.c_str(), msg.size());
132 g_unsupportedCount++;
133 } else {
134 g_supportedCount++;
135 }
136 g_allTestCount++;
137 }
138
CheckVideoHDRVivid2SDR(VideoProcessing_ColorSpaceInfo outInfo)139 static bool CheckVideoHDRVivid2SDR(VideoProcessing_ColorSpaceInfo outInfo)
140 {
141 switch (outInfo.metadataType) {
142 case OH_VIDEO_HDR_HLG:
143 case OH_VIDEO_HDR_HDR10:
144 case OH_VIDEO_HDR_VIVID:
145 return false;
146 default:
147 break;
148 }
149 switch (outInfo.colorSpace) {
150 case OH_COLORSPACE_BT709_LIMIT:
151 break;
152 default:
153 return false;
154 }
155 switch (outInfo.pixelFormat) {
156 case NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP:
157 case NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP:
158 case NATIVEBUFFER_PIXEL_FMT_RGBA_8888:
159 return true;
160 default:
161 return false;
162 }
163 }
164
CheckVideoVivid2Vivid(VideoProcessing_ColorSpaceInfo outInfo)165 static bool CheckVideoVivid2Vivid(VideoProcessing_ColorSpaceInfo outInfo)
166 {
167 if (outInfo.metadataType != OH_VIDEO_HDR_VIVID) {
168 return false;
169 }
170 return CheckHDRColorSpaceAndPixFmt(outInfo);
171 }
172
CheckVideoVivid2HDR(VideoProcessing_ColorSpaceInfo outInfo)173 static bool CheckVideoVivid2HDR(VideoProcessing_ColorSpaceInfo outInfo)
174 {
175 if (outInfo.metadataType != OH_VIDEO_HDR_HLG) {
176 return false;
177 }
178 return CheckHDRColorSpaceAndPixFmt(outInfo);
179 }
180
CheckVideoHDR2HDR(VideoProcessing_ColorSpaceInfo outInfo)181 static bool CheckVideoHDR2HDR(VideoProcessing_ColorSpaceInfo outInfo)
182 {
183 if (outInfo.metadataType != OH_VIDEO_HDR_HLG) {
184 return false;
185 }
186 return CheckHDRColorSpaceAndPixFmt(outInfo);
187 }
188
IsHDRConvert(VideoProcessing_ColorSpaceInfo inInfo,VideoProcessing_ColorSpaceInfo outInfo)189 static bool IsHDRConvert(VideoProcessing_ColorSpaceInfo inInfo, VideoProcessing_ColorSpaceInfo outInfo)
190 {
191 bool isVivid2SDR = false;
192 if (inInfo.metadataType == OH_VIDEO_HDR_VIVID && outInfo.metadataType == OH_VIDEO_NONE) {
193 isVivid2SDR = true;
194 }
195 if (!CheckHDRColorSpaceAndPixFmt(inInfo, isVivid2SDR)) {
196 return false;
197 }
198 if (inInfo.metadataType == OH_VIDEO_HDR_VIVID) {
199 if (inInfo.colorSpace == outInfo.colorSpace) {
200 return false;
201 }
202 bool isHDR2SDR = CheckVideoHDRVivid2SDR(outInfo);
203 bool isHDR2HDR = CheckVideoVivid2Vivid(outInfo);
204 bool isHDRVivid2HDR = false;
205 if (inInfo.colorSpace == OH_COLORSPACE_BT2020_PQ_LIMIT) {
206 isHDRVivid2HDR = CheckVideoVivid2HDR(outInfo);
207 }
208 return (isHDR2SDR || isHDR2HDR || isHDRVivid2HDR);
209 } else if (inInfo.metadataType == OH_VIDEO_HDR_HLG) {
210 return false;
211 } else {
212 if (inInfo.colorSpace == outInfo.colorSpace) {
213 return false;
214 }
215 return CheckVideoHDR2HDR(outInfo);
216 }
217 }
218
IsSDRConvert(VideoProcessing_ColorSpaceInfo inInfo,VideoProcessing_ColorSpaceInfo outInfo)219 static bool IsSDRConvert(VideoProcessing_ColorSpaceInfo inInfo, VideoProcessing_ColorSpaceInfo outInfo)
220 {
221 if (inInfo.colorSpace != OH_COLORSPACE_BT601_EBU_LIMIT && inInfo.colorSpace != OH_COLORSPACE_BT601_SMPTE_C_LIMIT) {
222 return false;
223 }
224 switch (inInfo.pixelFormat) {
225 case NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP:
226 case NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP:
227 case NATIVEBUFFER_PIXEL_FMT_RGBA_8888:
228 break;
229 default:
230 return false;
231 }
232 switch (outInfo.metadataType) {
233 case OH_VIDEO_HDR_HLG:
234 case OH_VIDEO_HDR_HDR10:
235 case OH_VIDEO_HDR_VIVID:
236 return false;
237 default:
238 break;
239 }
240 if (outInfo.colorSpace != OH_COLORSPACE_BT709_LIMIT) {
241 return false;
242 }
243 switch (outInfo.pixelFormat) {
244 case NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP:
245 case NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP:
246 case NATIVEBUFFER_PIXEL_FMT_RGBA_8888:
247 return true;
248 default:
249 return false;
250 }
251 }
252
CheckColorSpaceConvert(VideoProcessing_ColorSpaceInfo inInfo,VideoProcessing_ColorSpaceInfo outInfo)253 static void CheckColorSpaceConvert(VideoProcessing_ColorSpaceInfo inInfo, VideoProcessing_ColorSpaceInfo outInfo)
254 {
255 bool expectVal = false;
256 switch (inInfo.metadataType) {
257 case OH_VIDEO_HDR_HLG:
258 case OH_VIDEO_HDR_HDR10:
259 case OH_VIDEO_HDR_VIVID:
260 expectVal = IsHDRConvert(inInfo, outInfo);
261 break;
262 default:
263 expectVal = IsSDRConvert(inInfo, outInfo);
264 break;
265 }
266 bool realVal = OH_VideoProcessing_IsColorSpaceConversionSupported(&inInfo, &outInfo);
267 if (expectVal != realVal) {
268 string msg = "-----------------------------------------------\n";
269 msg += "convert in type:" + metadataString[inInfo.metadataType] + "\n";
270 msg += "colorspace:" + colorString[inInfo.colorSpace] + "\n";
271 msg += "format:" + formatString[inInfo.pixelFormat] + "\n";
272 msg += "convert out type:" + metadataString[outInfo.metadataType] + "\n";
273 msg += "colorspace:" + colorString[outInfo.colorSpace] + "\n";
274 msg += "format:" + formatString[outInfo.pixelFormat] + "\n";
275 msg += "expect" + BoolToString(expectVal) + " actual:" + BoolToString(realVal) + "\n";
276 msg += "-----------------------------------------------\n";
277 outputListFile->write(msg.c_str(), msg.size());
278 g_unsupportedCount++;
279 } else {
280 g_supportedCount++;
281 }
282 g_allTestCount++;
283 }
284
GenOutputOptions(VideoProcessing_ColorSpaceInfo inInfo)285 static void GenOutputOptions(VideoProcessing_ColorSpaceInfo inInfo)
286 {
287 for (int i :NativeBuffer_MetadataType) {
288 for (int j : NativeBuffer_ColorSpace) {
289 for (int k : NativeBuffer_Format) {
290 VideoProcessing_ColorSpaceInfo outInfo;
291 outInfo.metadataType = i;
292 outInfo.colorSpace = j;
293 outInfo.pixelFormat = k;
294 CheckColorSpaceConvert(inInfo, outInfo);
295 }
296 }
297 }
298 }
299
300 /**
301 * @tc.number : VPE_VIDEO_RELI_TEST_0010
302 * @tc.name : test all metadataGenerate options
303 * @tc.desc : function test
304 */
305 HWTEST_F(VpeVideoReliTest, VPE_VIDEO_RELI_TEST_0010, TestSize.Level2)
306 {
307 outputListFile = std::make_unique<std::ofstream>("/data/test/media/metadataSupportList.txt");
308 for (int i : NativeBuffer_MetadataType) {
309 for (int j : NativeBuffer_ColorSpace) {
310 for (int k : NativeBuffer_Format) {
311 VideoProcessing_ColorSpaceInfo info;
312 info.metadataType = i;
313 info.colorSpace = j;
314 info.pixelFormat = k;
315 CheckMetadataGen(info);
316 }
317 }
318 }
319 cout << "all test " << g_allTestCount <<endl;
320 cout << "matched test " << g_supportedCount <<endl;
321 cout<< "mismatched test" << g_unsupportedCount <<endl;
322 outputListFile->close();
323 outputListFile = nullptr;
324 ASSERT_EQ(g_unsupportedCount, 0);
325 }
326
327 /**
328 * @tc.number : VPE_VIDEO_RELI_TEST_0020
329 * @tc.name : test all colorspace convert options
330 * @tc.desc : function test
331 */
332 HWTEST_F(VpeVideoReliTest, VPE_VIDEO_RELI_TEST_0020, TestSize.Level2)
333 {
334 outputListFile = std::make_unique<std::ofstream>("/data/test/media/convertSupportList.txt");
335 for (int i : NativeBuffer_MetadataType) {
336 for (int j : NativeBuffer_ColorSpace) {
337 for (int k : NativeBuffer_Format) {
338 VideoProcessing_ColorSpaceInfo info;
339 info.metadataType = i;
340 info.colorSpace = j;
341 info.pixelFormat = k;
342 GenOutputOptions(info);
343 }
344 }
345 }
346 cout << "all test " << g_allTestCount <<endl;
347 cout << "matched test " << g_supportedCount <<endl;
348 cout<< "mismatched test" << g_unsupportedCount <<endl;
349 outputListFile->close();
350 outputListFile = nullptr;
351 ASSERT_EQ(g_unsupportedCount, 0);
352 }
353 #endif
354 }