1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "display_gralloc_test.h"
17 #include <securec.h>
18 #include "gtest/gtest.h"
19 #include "display_gralloc.h"
20 #include "display_test.h"
21
22 namespace {
23 #define ALIGN_UP(x, a) ((((x) + ((a)-1)) / (a)) * (a))
24 static constexpr uint8_t WIDTH_ALIGN = 8;
25
26 const AllocTestPrms GRALLOC_TEST_SETS[] = {
27 {
28 .allocInfo = {
29 .width = 1920,
30 .height = 1080,
31 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
32 .format = PIXEL_FMT_RGBX_8888
33 },
34 .expectStride = 1920 * 4,
35 .expectSize = 1920 * 1080 * 4
36 },
37
38 {
39 .allocInfo = {
40 .width = 1080,
41 .height = 1920,
42 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
43 .format = PIXEL_FMT_RGBX_8888
44 },
45 .expectStride = 1080 * 4,
46 .expectSize = 1080 * 1920 * 4
47 },
48
49 {
50 .allocInfo = {
51 .width = 1280,
52 .height = 720,
53 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
54 .format = PIXEL_FMT_RGBX_8888
55 },
56 .expectStride = 1280 * 4,
57 .expectSize = 1280 * 720 * 4
58 },
59
60 {
61 .allocInfo = {
62 .width = 1080,
63 .height = 1920,
64 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
65 .format = PIXEL_FMT_RGBA_8888
66 },
67 .expectStride = 1080 * 4,
68 .expectSize = 1080 * 1920 * 4
69 },
70
71 {
72 .allocInfo = {
73 .width = 1080,
74 .height = 1920,
75 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
76 .format = PIXEL_FMT_RGB_888
77 },
78 .expectStride = 1080 * 3,
79 .expectSize = 1080 * 1920 * 3
80 },
81
82 {
83 .allocInfo = {
84 .width = 1080,
85 .height = 1920,
86 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
87 .format = PIXEL_FMT_BGRA_8888
88 },
89 .expectStride = 1080 * 4,
90 .expectSize = 1080 * 1920 * 4
91 },
92
93 {
94 .allocInfo = {
95 .width = 1080,
96 .height = 1920,
97 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
98 .format = PIXEL_FMT_BGRX_8888
99 },
100 .expectStride = 1080 * 4,
101 .expectSize = 1080 * 1920 * 4
102 },
103
104 {
105 .allocInfo = {
106 .width = 1080,
107 .height = 1920,
108 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
109 .format = PIXEL_FMT_RGBA_4444
110 },
111 .expectStride = 1080 * 2,
112 .expectSize = 1080 * 1920 * 2
113 },
114
115 {
116 .allocInfo =
117 {
118 .width = 1080,
119 .height = 1920,
120 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
121 .format = PIXEL_FMT_RGBX_4444
122 },
123 .expectStride = 1080 * 2,
124 .expectSize = 1080 * 1920 * 2
125 },
126
127 {
128 .allocInfo = {
129 .width = 1080,
130 .height = 1920,
131 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
132 .format = PIXEL_FMT_BGRA_4444
133 },
134 .expectStride = 1080 * 2,
135 .expectSize = 1080 * 1920 * 2
136 },
137
138 {
139 .allocInfo = {
140 .width = 1080,
141 .height = 1920,
142 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
143 .format = PIXEL_FMT_BGRX_4444
144 },
145 .expectStride = 1080 * 2,
146 .expectSize = 1080 * 1920 * 2
147 },
148
149 {
150 .allocInfo = {
151 .width = 1080,
152 .height = 1920,
153 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
154 .format = PIXEL_FMT_BGR_565
155 },
156 .expectStride = 1080 * 2,
157 .expectSize = 1080 * 1920 * 2
158 },
159
160 {
161 .allocInfo = {
162 .width = 1080,
163 .height = 1920,
164 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
165 .format = PIXEL_FMT_BGRA_5551
166 },
167 .expectStride = 1080 * 2,
168 .expectSize = 1080 * 1920 * 2
169 },
170
171 {
172 .allocInfo = {
173 .width = 1080,
174 .height = 1920,
175 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
176 .format = PIXEL_FMT_BGRX_5551
177 },
178 .expectStride = 1080 * 2,
179 .expectSize = 1080 * 1920 * 2
180 },
181
182 {
183 .allocInfo = {
184 .width = 1080,
185 .height = 1920,
186 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
187 .format = PIXEL_FMT_YCBCR_420_SP
188 },
189 .expectStride = ALIGN_UP(1080, WIDTH_ALIGN),
190 .expectSize = (ALIGN_UP(1080, WIDTH_ALIGN) * 1920) * 3 / 2,
191 },
192
193 {
194 .allocInfo = {
195 .width = 1080,
196 .height = 1920,
197 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
198 .format = PIXEL_FMT_YCRCB_420_SP
199 },
200 .expectStride = ALIGN_UP(1080, WIDTH_ALIGN),
201 .expectSize = (ALIGN_UP(1080, WIDTH_ALIGN) * 1920) * 3 / 2,
202 },
203
204 {
205 .allocInfo = {
206 .width = 1080,
207 .height = 1920,
208 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
209 .format = PIXEL_FMT_YCBCR_420_P
210 },
211 .expectStride = ALIGN_UP(1080, WIDTH_ALIGN),
212 .expectSize = (ALIGN_UP(1080, WIDTH_ALIGN) * 1920) * 3 / 2,
213 },
214
215 {
216 .allocInfo = {
217 .width = 1080,
218 .height = 1920,
219 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ | HBM_USE_CPU_WRITE,
220 .format = PIXEL_FMT_YCRCB_420_P
221 },
222 .expectStride = ALIGN_UP(1080, WIDTH_ALIGN),
223 .expectSize = (ALIGN_UP(1080, WIDTH_ALIGN) * 1920) * 3 / 2,
224 },
225
226 {
227 .allocInfo = {
228 .width = 1080,
229 .height = 1920,
230 .usage = HBM_USE_MEM_DMA,
231 .format = PIXEL_FMT_RGBX_8888
232 },
233 .expectStride = 1080 * 4,
234 .expectSize = 1080 * 1920 * 4,
235 },
236
237 {
238 .allocInfo = {
239 .width = 1080,
240 .height = 1920,
241 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_READ,
242 .format = PIXEL_FMT_RGBX_8888
243 },
244 .expectStride = 1080 * 4,
245 .expectSize = 1080 * 1920 * 4,
246 },
247
248 {
249 .allocInfo = {
250 .width = 1080,
251 .height = 1920,
252 .usage = HBM_USE_MEM_DMA | HBM_USE_CPU_WRITE,
253 .format = PIXEL_FMT_RGBX_8888
254 },
255 .expectStride = 1080 * 4,
256 .expectSize = 1080 * 1920 * 4,
257 },
258 };
259
CheckBufferHandle(AllocTestPrms & info,BufferHandle & buffer)260 static bool CheckBufferHandle(AllocTestPrms &info, BufferHandle &buffer)
261 {
262 if (buffer.stride != (ALIGN_UP(info.expectStride, WIDTH_ALIGN))) {
263 DISPLAY_TEST_LOGE("stride check faild stride %d, expect stride %d ", buffer.stride, info.expectStride);
264 DISPLAY_TEST_LOGE("stride check faild format %d width %d, height %d ", info.allocInfo.format,
265 info.allocInfo.width, info.allocInfo.height);
266 return false;
267 }
268
269 if (buffer.size != info.expectSize) {
270 DISPLAY_TEST_LOGE("size check faild size %d, expect size %d ", buffer.size, info.expectSize);
271 DISPLAY_TEST_LOGE("stride check faild format %d width %d, height %d ", info.allocInfo.format,
272 info.allocInfo.width, info.allocInfo.height);
273 return false;
274 }
275 return true;
276 }
277
SetUp()278 void GrallocAllocTest::SetUp()
279 {
280 if (GrallocInitialize(&mGrallocFuncs) != DISPLAY_SUCCESS) {
281 DISPLAY_TEST_LOGE("DisplayInit failure\n");
282 ASSERT_TRUE(0);
283 }
284 }
285
TearDown()286 void GrallocAllocTest::TearDown()
287 {
288 if (GrallocUninitialize(mGrallocFuncs) != DISPLAY_SUCCESS) {
289 DISPLAY_TEST_LOGE("DisplayUninit failure\n");
290 ASSERT_TRUE(0);
291 }
292 }
293
AllocMemTest(AllocTestPrms & info)294 int32_t GrallocAllocTest::AllocMemTest(AllocTestPrms &info)
295 {
296 int ret;
297 BufferHandle *buffer = nullptr;
298 const int testCount = 1; // test 40 times
299 for (int i = 0; i < testCount; i++) {
300 ret = mGrallocFuncs->AllocMem(&info.allocInfo, &buffer);
301 if (ret != DISPLAY_SUCCESS) {
302 return ret;
303 }
304 void *vAddr = mGrallocFuncs->Mmap(buffer);
305 if (vAddr == nullptr) {
306 return DISPLAY_FAILURE;
307 }
308
309 if (info.allocInfo.usage & (HBM_USE_CPU_READ | HBM_USE_CPU_WRITE)) {
310 ret = mGrallocFuncs->InvalidateCache(buffer);
311 if (ret != DISPLAY_SUCCESS) {
312 return ret;
313 }
314 }
315 if (memset_s(vAddr, buffer->size, 0, buffer->size) != EOK) {
316 return DISPLAY_NOMEM;
317 }
318 DISPLAY_TEST_CHK_RETURN(!CheckBufferHandle(info, *buffer), DISPLAY_FAILURE,
319 DISPLAY_TEST_LOGE("buffer check failed"));
320 if (info.allocInfo.usage & (HBM_USE_CPU_READ | HBM_USE_CPU_WRITE)) {
321 ret = mGrallocFuncs->FlushCache(buffer);
322 if (ret != DISPLAY_SUCCESS) {
323 return ret;
324 }
325 }
326 mGrallocFuncs->Unmap((buffer));
327 mGrallocFuncs->FreeMem(buffer);
328 }
329
330 return DISPLAY_SUCCESS;
331 }
332
TEST(GrallocAllocTest,NULLPTR)333 TEST(GrallocAllocTest, NULLPTR)
334 {
335 int ret = GrallocInitialize(nullptr);
336 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
337
338 GrallocFuncs *grallocFuncs;
339 AllocInfo allocInfo;
340 BufferHandle *hdl;
341 ret = GrallocInitialize(&grallocFuncs);
342 ASSERT_TRUE(ret == DISPLAY_SUCCESS);
343 ret = grallocFuncs->AllocMem(nullptr, nullptr);
344 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
345 ret = grallocFuncs->AllocMem(&allocInfo, nullptr);
346 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
347 ret = grallocFuncs->AllocMem(nullptr, &hdl);
348 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
349 ret = grallocFuncs->InvalidateCache(nullptr);
350 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
351 ret = grallocFuncs->FlushCache(nullptr);
352 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
353 grallocFuncs->FreeMem(nullptr);
354 void *vAddr = grallocFuncs->Mmap(nullptr);
355 ASSERT_TRUE(vAddr == nullptr);
356 ret = grallocFuncs->Unmap(nullptr);
357 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
358 ret = GrallocUninitialize(nullptr);
359 ASSERT_TRUE(ret != DISPLAY_SUCCESS);
360
361 ret = GrallocUninitialize(grallocFuncs);
362 ASSERT_TRUE(ret == DISPLAY_SUCCESS);
363 }
364
TEST_P(GrallocAllocTest,GrallocAlloc)365 TEST_P(GrallocAllocTest, GrallocAlloc)
366 {
367 AllocTestPrms params = GetParam();
368 int ret = AllocMemTest(params);
369 ASSERT_TRUE(ret == DISPLAY_SUCCESS);
370 }
371
372 INSTANTIATE_TEST_CASE_P(AllocTest, GrallocAllocTest, ::testing::ValuesIn(GRALLOC_TEST_SETS));
373 }
374