1 #pragma once
2 /*
3 * Copyright (C) 2016 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 #include <stdint.h>
18 #include <limits.h>
19 #include <string.h>
20 #include <sys/cdefs.h>
21 #include <sys/mman.h>
22 #include <hardware/gralloc.h>
23 #include <errno.h>
24 #include <unistd.h>
25 #include <string.h>
26
27 #include <cutils/native_handle.h>
28 #include <log/log.h>
29
30 #include <linux/fb.h>
31
32 #include "common/vsoc/lib/screen_region_view.h"
33 #include "guest/libs/platform_support/api_level_fixes.h"
34
35 #ifndef GRALLOC_MODULE_API_VERSION_0_2
36 // This structure will be defined in later releases of Android. Declare it
37 // here to allow us to structure the code well.
38 struct android_ycbcr {
39 void* y;
40 void* cb;
41 void* cr;
42 size_t ystride;
43 size_t cstride;
44 size_t chroma_step;
45 uint32_t reserved[8];
46 };
47 #endif
48
49 /*****************************************************************************/
50
51 struct private_handle_t;
52
53 struct private_module_t {
54 gralloc_module_t base;
55 };
56
57 /*****************************************************************************/
58
59 struct priv_alloc_device_t {
60 alloc_device_t device;
61 };
62
63 /*****************************************************************************/
64
65 struct private_handle_t : public native_handle {
66 // file-descriptors
67 int fd;
68 // ints
69 int magic;
70 int flags;
71 int format;
72 int x_res;
73 int y_res;
74 int stride_in_pixels;
75 // Use to indicate which frame we're using.
76 int frame_offset;
77 int total_size;
78 int lock_level;
79
sNumIntsprivate_handle_t80 static inline int sNumInts() {
81 return (((sizeof(private_handle_t) - sizeof(native_handle_t))/sizeof(int)) - sNumFds);
82 }
83 static const int sNumFds = 1;
84 static const int sMagic = 0x3141592;
85
86 private_handle_t(int fd, int size, int format, int x_res, int y_res,
87 int stride_in_pixels, int flags, int frame_offset = 0)
fdprivate_handle_t88 : fd(fd),
89 magic(sMagic),
90 flags(flags),
91 format(format),
92 x_res(x_res),
93 y_res(y_res),
94 stride_in_pixels(stride_in_pixels),
95 frame_offset(frame_offset),
96 total_size(size),
97 lock_level(0) {
98 version = sizeof(native_handle);
99 numInts = sNumInts();
100 numFds = sNumFds;
101 }
102
~private_handle_tprivate_handle_t103 ~private_handle_t() {
104 magic = 0;
105 }
106
validateprivate_handle_t107 static int validate(const native_handle* h) {
108 const private_handle_t* hnd = (const private_handle_t*)h;
109 if (!h) {
110 ALOGE("invalid gralloc handle (at %p): NULL pointer", h);
111 return -EINVAL;
112 }
113 if (h->version != sizeof(native_handle)) {
114 ALOGE(
115 "invalid gralloc handle (at %p): Wrong version(observed: %d, "
116 "expected: %zu)",
117 h,
118 h->version,
119 sizeof(native_handle));
120 return -EINVAL;
121 }
122 if (h->numInts != sNumInts()) {
123 ALOGE(
124 "invalid gralloc handle (at %p): Wrong number of ints(observed: %d, "
125 "expected: %d)",
126 h,
127 h->numInts,
128 sNumInts());
129 return -EINVAL;
130 }
131 if (h->numFds != sNumFds) {
132 ALOGE(
133 "invalid gralloc handle (at %p): Wrong number of file "
134 "descriptors(observed: %d, expected: %d)",
135 h,
136 h->numFds,
137 sNumFds);
138 return -EINVAL;
139 }
140 if (hnd->magic != sMagic) {
141 ALOGE(
142 "invalid gralloc handle (at %p): Wrong magic number(observed: %d, "
143 "expected: %d)",
144 h,
145 hnd->magic,
146 sMagic);
147 return -EINVAL;
148 }
149 return 0;
150 }
151 };
152
153
formatToBytesPerPixel(int format)154 static inline int formatToBytesPerPixel(int format) {
155 switch (format) {
156 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
157 case HAL_PIXEL_FORMAT_RGBA_FP16:
158 return 8;
159 #endif
160 case HAL_PIXEL_FORMAT_RGBA_8888:
161 case HAL_PIXEL_FORMAT_RGBX_8888:
162 case HAL_PIXEL_FORMAT_BGRA_8888:
163 #if VSOC_PLATFORM_SDK_AFTER(J)
164 // The camera 3.0 implementation assumes that IMPLEMENTATION_DEFINED
165 // means HAL_PIXEL_FORMAT_RGBA_8888
166 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
167 #endif
168 return 4;
169 case HAL_PIXEL_FORMAT_RGB_888:
170 return 3;
171 case HAL_PIXEL_FORMAT_RGB_565:
172 case HAL_PIXEL_FORMAT_YV12:
173 #ifdef GRALLOC_MODULE_API_VERSION_0_2
174 case HAL_PIXEL_FORMAT_YCbCr_420_888:
175 #endif
176 return 2;
177 #if VSOC_PLATFORM_SDK_AFTER(J)
178 case HAL_PIXEL_FORMAT_BLOB:
179 return 1;
180 #endif
181 default:
182 ALOGE("%s: unknown format=%d", __FUNCTION__, format);
183 return 8;
184 }
185 }
186
pixel_format_to_string(int format)187 inline const char* pixel_format_to_string(int format) {
188 switch (format) {
189 // Formats that are universal across versions
190 case HAL_PIXEL_FORMAT_RGBA_8888:
191 return "RGBA_8888";
192 case HAL_PIXEL_FORMAT_RGBX_8888:
193 return "RGBX_8888";
194 case HAL_PIXEL_FORMAT_BGRA_8888:
195 return "BGRA_8888";
196 case HAL_PIXEL_FORMAT_RGB_888:
197 return "RGB_888";
198 case HAL_PIXEL_FORMAT_RGB_565:
199 return "RGB_565";
200 case HAL_PIXEL_FORMAT_YV12:
201 return "YV12";
202 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
203 return "YCrCb_420_SP";
204 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
205 return "YCbCr_422_SP";
206 case HAL_PIXEL_FORMAT_YCbCr_422_I:
207 return "YCbCr_422_I";
208
209 #if VSOC_PLATFORM_SDK_AFTER(J)
210 // First supported on JBMR1 (API 17)
211 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
212 return "IMPLEMENTATION_DEFINED";
213 case HAL_PIXEL_FORMAT_BLOB:
214 return "BLOB";
215 #endif
216 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
217 // First supported on JBMR2 (API 18)
218 case HAL_PIXEL_FORMAT_YCbCr_420_888:
219 return "YCbCr_420_888";
220 case HAL_PIXEL_FORMAT_Y8:
221 return "Y8";
222 case HAL_PIXEL_FORMAT_Y16:
223 return "Y16";
224 #endif
225 #if VSOC_PLATFORM_SDK_AFTER(K)
226 // Support was added in L (API 21)
227 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
228 return "RAW_OPAQUE";
229 // This is an alias for RAW_SENSOR in L and replaces it in M.
230 case HAL_PIXEL_FORMAT_RAW16:
231 return "RAW16";
232 case HAL_PIXEL_FORMAT_RAW10:
233 return "RAW10";
234 #endif
235 #if VSOC_PLATFORM_SDK_AFTER(L_MR1)
236 case HAL_PIXEL_FORMAT_YCbCr_444_888:
237 return "YCbCr_444_888";
238 case HAL_PIXEL_FORMAT_YCbCr_422_888:
239 return "YCbCr_422_888";
240 case HAL_PIXEL_FORMAT_RAW12:
241 return "RAW12";
242 case HAL_PIXEL_FORMAT_FLEX_RGBA_8888:
243 return "FLEX_RGBA_8888";
244 case HAL_PIXEL_FORMAT_FLEX_RGB_888:
245 return "FLEX_RGB_888";
246 #endif
247 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
248 case HAL_PIXEL_FORMAT_RGBA_FP16:
249 return "RGBA_FP16";
250 #endif
251
252 // Formats that have been removed
253 #if VSOC_PLATFORM_SDK_BEFORE(K)
254 // Support was dropped on K (API 19)
255 case HAL_PIXEL_FORMAT_RGBA_5551:
256 return "RGBA_5551";
257 case HAL_PIXEL_FORMAT_RGBA_4444:
258 return "RGBA_4444";
259 #endif
260 #if VSOC_PLATFORM_SDK_BEFORE(L)
261 // Renamed to RAW_16 in L. Both were present for L, but it was completely
262 // removed in M.
263 case HAL_PIXEL_FORMAT_RAW_SENSOR:
264 return "RAW_SENSOR";
265 #endif
266 #if VSOC_PLATFORM_SDK_AFTER(J_MR2) && VSOC_PLATFORM_SDK_BEFORE(M)
267 // Supported K, L, and LMR1. Not supported on JBMR0, JBMR1, JBMR2, and M
268 case HAL_PIXEL_FORMAT_sRGB_X_8888:
269 return "sRGB_X_8888";
270 case HAL_PIXEL_FORMAT_sRGB_A_8888:
271 return "sRGB_A_8888";
272 #endif
273 }
274 return "UNKNOWN";
275 }
276
277
formatToYcbcr(int format,int width,int height,void * base_v,android_ycbcr * out)278 static inline void formatToYcbcr(
279 int format, int width, int height, void* base_v, android_ycbcr* out) {
280 char* it = static_cast<char*>(base_v);
281 // Clear reserved fields;
282 memset(out, 0, sizeof(*out));
283 switch (format) {
284 case HAL_PIXEL_FORMAT_YV12:
285 #ifdef GRALLOC_MODULE_API_VERSION_0_2
286 case HAL_PIXEL_FORMAT_YCbCr_420_888:
287 #endif
288 out->ystride = vsoc::screen::ScreenRegionView::align(width, 16);
289 out->cstride =
290 vsoc::screen::ScreenRegionView::align(out->ystride / 2, 16);
291 out->chroma_step = 1;
292 out->y = it;
293 it += out->ystride * height;
294 out->cr = it;
295 it += out->cstride * height / 2;
296 out->cb = it;
297 break;
298 default:
299 ALOGE("%s: can't deal with format=0x%x (%s)",
300 __FUNCTION__, format, pixel_format_to_string(format));
301 }
302 }
303
formatToBytesPerFrame(int format,int w,int h)304 static inline int formatToBytesPerFrame(int format, int w, int h) {
305 int bytes_per_pixel = formatToBytesPerPixel(format);
306 int w16, h16;
307 int y_size, c_size;
308
309 switch (format) {
310 #if VSOC_PLATFORM_SDK_AFTER(J)
311 // BLOB is used to allocate buffers for JPEG formatted data. Bytes per pixel
312 // is 1, the desired buffer size is in w, and h should be 1. We refrain from
313 // adding additional padding, although the caller is likely to round
314 // up to a page size.
315 case HAL_PIXEL_FORMAT_BLOB:
316 return bytes_per_pixel * w * h;
317 #endif
318 case HAL_PIXEL_FORMAT_YV12:
319 #ifdef GRALLOC_MODULE_API_VERSION_0_2
320 case HAL_PIXEL_FORMAT_YCbCr_420_888:
321 #endif
322 android_ycbcr strides;
323 formatToYcbcr(format, w, h, NULL, &strides);
324 y_size = strides.ystride * h;
325 c_size = strides.cstride * h / 2;
326 return (y_size + 2 * c_size +
327 vsoc::screen::ScreenRegionView::kSwiftShaderPadding);
328 /*case HAL_PIXEL_FORMAT_RGBA_8888:
329 case HAL_PIXEL_FORMAT_RGBX_8888:
330 case HAL_PIXEL_FORMAT_BGRA_8888:
331 case HAL_PIXEL_FORMAT_RGB_888:
332 case HAL_PIXEL_FORMAT_RGB_565:*/
333 default:
334 w16 = vsoc::screen::ScreenRegionView::align(w, 16);
335 h16 = vsoc::screen::ScreenRegionView::align(h, 16);
336 return bytes_per_pixel * w16 * h16 +
337 vsoc::screen::ScreenRegionView::kSwiftShaderPadding;
338 }
339 }
340
341 int fb_device_open(
342 const hw_module_t* module, const char* name, hw_device_t** device);
343
344 int gralloc_lock(
345 gralloc_module_t const* module,
346 buffer_handle_t handle, int usage,
347 int l, int t, int w, int h,
348 void** vaddr);
349
350 int gralloc_unlock(
351 gralloc_module_t const* module, buffer_handle_t handle);
352
353 int gralloc_register_buffer(
354 gralloc_module_t const* module, buffer_handle_t handle);
355
356 int gralloc_unregister_buffer(
357 gralloc_module_t const* module, buffer_handle_t handle);
358
359 int gralloc_lock_ycbcr(
360 struct gralloc_module_t const* module,
361 buffer_handle_t handle, int usage,
362 int l, int t, int w, int h,
363 struct android_ycbcr *ycbcr);
364