Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 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> |
Sandeep Patil | cef10fc | 2018-07-26 08:08:44 -0700 | [diff] [blame] | 19 | #include <string.h> |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 20 | #include <sys/cdefs.h> |
| 21 | #include <sys/mman.h> |
| 22 | #include <hardware/gralloc.h> |
| 23 | #include <errno.h> |
| 24 | #include <unistd.h> |
Marissa Wall | d329f56 | 2018-01-28 10:53:10 -0800 | [diff] [blame] | 25 | #include <string.h> |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 26 | |
| 27 | #include <cutils/native_handle.h> |
Colin Cross | d193549 | 2018-09-06 14:08:55 -0700 | [diff] [blame] | 28 | #include <log/log.h> |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 29 | |
| 30 | #include <linux/fb.h> |
| 31 | |
Cody Schuffelen | 134ff03 | 2019-11-22 00:25:32 -0800 | [diff] [blame^] | 32 | #include "common/vsoc/lib/screen_region_view.h" |
| 33 | |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 34 | #ifndef GRALLOC_MODULE_API_VERSION_0_2 |
| 35 | // This structure will be defined in later releases of Android. Declare it |
| 36 | // here to allow us to structure the code well. |
| 37 | struct android_ycbcr { |
| 38 | void* y; |
| 39 | void* cb; |
| 40 | void* cr; |
| 41 | size_t ystride; |
| 42 | size_t cstride; |
| 43 | size_t chroma_step; |
| 44 | uint32_t reserved[8]; |
| 45 | }; |
| 46 | #endif |
| 47 | |
| 48 | /*****************************************************************************/ |
| 49 | |
| 50 | struct private_handle_t; |
| 51 | |
| 52 | struct private_module_t { |
| 53 | gralloc_module_t base; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 54 | }; |
| 55 | |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 56 | /*****************************************************************************/ |
| 57 | |
| 58 | struct priv_alloc_device_t { |
| 59 | alloc_device_t device; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 60 | }; |
| 61 | |
| 62 | /*****************************************************************************/ |
| 63 | |
| 64 | struct private_handle_t : public native_handle { |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 65 | // file-descriptors |
| 66 | int fd; |
| 67 | // ints |
| 68 | int magic; |
| 69 | int flags; |
| 70 | int format; |
| 71 | int x_res; |
| 72 | int y_res; |
| 73 | int stride_in_pixels; |
| 74 | // Use to indicate which frame we're using. |
| 75 | int frame_offset; |
| 76 | int total_size; |
| 77 | int lock_level; |
| 78 | |
| 79 | static inline int sNumInts() { |
| 80 | return (((sizeof(private_handle_t) - sizeof(native_handle_t))/sizeof(int)) - sNumFds); |
| 81 | } |
| 82 | static const int sNumFds = 1; |
| 83 | static const int sMagic = 0x3141592; |
| 84 | |
| 85 | private_handle_t(int fd, int size, int format, int x_res, int y_res, |
| 86 | int stride_in_pixels, int flags, int frame_offset = 0) |
| 87 | : fd(fd), |
| 88 | magic(sMagic), |
| 89 | flags(flags), |
| 90 | format(format), |
| 91 | x_res(x_res), |
| 92 | y_res(y_res), |
| 93 | stride_in_pixels(stride_in_pixels), |
| 94 | frame_offset(frame_offset), |
| 95 | total_size(size), |
| 96 | lock_level(0) { |
| 97 | version = sizeof(native_handle); |
| 98 | numInts = sNumInts(); |
| 99 | numFds = sNumFds; |
| 100 | } |
| 101 | |
| 102 | ~private_handle_t() { |
| 103 | magic = 0; |
| 104 | } |
| 105 | |
| 106 | static int validate(const native_handle* h) { |
| 107 | const private_handle_t* hnd = (const private_handle_t*)h; |
Jorge E. Moreira | 477277c | 2018-02-08 11:30:53 -0800 | [diff] [blame] | 108 | if (!h) { |
| 109 | ALOGE("invalid gralloc handle (at %p): NULL pointer", h); |
| 110 | return -EINVAL; |
| 111 | } |
| 112 | if (h->version != sizeof(native_handle)) { |
| 113 | ALOGE( |
| 114 | "invalid gralloc handle (at %p): Wrong version(observed: %d, " |
| 115 | "expected: %zu)", |
| 116 | h, |
| 117 | h->version, |
| 118 | sizeof(native_handle)); |
| 119 | return -EINVAL; |
| 120 | } |
| 121 | if (h->numInts != sNumInts()) { |
| 122 | ALOGE( |
| 123 | "invalid gralloc handle (at %p): Wrong number of ints(observed: %d, " |
| 124 | "expected: %d)", |
| 125 | h, |
| 126 | h->numInts, |
| 127 | sNumInts()); |
| 128 | return -EINVAL; |
| 129 | } |
| 130 | if (h->numFds != sNumFds) { |
| 131 | ALOGE( |
| 132 | "invalid gralloc handle (at %p): Wrong number of file " |
| 133 | "descriptors(observed: %d, expected: %d)", |
| 134 | h, |
| 135 | h->numFds, |
| 136 | sNumFds); |
| 137 | return -EINVAL; |
| 138 | } |
| 139 | if (hnd->magic != sMagic) { |
| 140 | ALOGE( |
| 141 | "invalid gralloc handle (at %p): Wrong magic number(observed: %d, " |
| 142 | "expected: %d)", |
| 143 | h, |
| 144 | hnd->magic, |
| 145 | sMagic); |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 146 | return -EINVAL; |
| 147 | } |
| 148 | return 0; |
| 149 | } |
| 150 | }; |
| 151 | |
| 152 | |
| 153 | static inline int formatToBytesPerPixel(int format) { |
| 154 | switch (format) { |
Greg Hartman | 21288ad | 2018-04-17 17:51:25 -0700 | [diff] [blame] | 155 | case HAL_PIXEL_FORMAT_RGBA_FP16: |
| 156 | return 8; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 157 | case HAL_PIXEL_FORMAT_RGBA_8888: |
| 158 | case HAL_PIXEL_FORMAT_RGBX_8888: |
| 159 | case HAL_PIXEL_FORMAT_BGRA_8888: |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 160 | // The camera 3.0 implementation assumes that IMPLEMENTATION_DEFINED |
| 161 | // means HAL_PIXEL_FORMAT_RGBA_8888 |
| 162 | case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 163 | return 4; |
| 164 | case HAL_PIXEL_FORMAT_RGB_888: |
| 165 | return 3; |
| 166 | case HAL_PIXEL_FORMAT_RGB_565: |
| 167 | case HAL_PIXEL_FORMAT_YV12: |
| 168 | #ifdef GRALLOC_MODULE_API_VERSION_0_2 |
| 169 | case HAL_PIXEL_FORMAT_YCbCr_420_888: |
| 170 | #endif |
| 171 | return 2; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 172 | case HAL_PIXEL_FORMAT_BLOB: |
| 173 | return 1; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 174 | default: |
| 175 | ALOGE("%s: unknown format=%d", __FUNCTION__, format); |
Greg Hartman | 21288ad | 2018-04-17 17:51:25 -0700 | [diff] [blame] | 176 | return 8; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 177 | } |
| 178 | } |
| 179 | |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 180 | inline const char* pixel_format_to_string(int format) { |
| 181 | switch (format) { |
| 182 | // Formats that are universal across versions |
| 183 | case HAL_PIXEL_FORMAT_RGBA_8888: |
| 184 | return "RGBA_8888"; |
| 185 | case HAL_PIXEL_FORMAT_RGBX_8888: |
| 186 | return "RGBX_8888"; |
| 187 | case HAL_PIXEL_FORMAT_BGRA_8888: |
| 188 | return "BGRA_8888"; |
| 189 | case HAL_PIXEL_FORMAT_RGB_888: |
| 190 | return "RGB_888"; |
| 191 | case HAL_PIXEL_FORMAT_RGB_565: |
| 192 | return "RGB_565"; |
| 193 | case HAL_PIXEL_FORMAT_YV12: |
| 194 | return "YV12"; |
| 195 | case HAL_PIXEL_FORMAT_YCrCb_420_SP: |
| 196 | return "YCrCb_420_SP"; |
| 197 | case HAL_PIXEL_FORMAT_YCbCr_422_SP: |
| 198 | return "YCbCr_422_SP"; |
| 199 | case HAL_PIXEL_FORMAT_YCbCr_422_I: |
| 200 | return "YCbCr_422_I"; |
| 201 | |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 202 | // First supported on JBMR1 (API 17) |
| 203 | case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: |
| 204 | return "IMPLEMENTATION_DEFINED"; |
| 205 | case HAL_PIXEL_FORMAT_BLOB: |
| 206 | return "BLOB"; |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 207 | // First supported on JBMR2 (API 18) |
| 208 | case HAL_PIXEL_FORMAT_YCbCr_420_888: |
| 209 | return "YCbCr_420_888"; |
| 210 | case HAL_PIXEL_FORMAT_Y8: |
| 211 | return "Y8"; |
| 212 | case HAL_PIXEL_FORMAT_Y16: |
| 213 | return "Y16"; |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 214 | // Support was added in L (API 21) |
| 215 | case HAL_PIXEL_FORMAT_RAW_OPAQUE: |
| 216 | return "RAW_OPAQUE"; |
| 217 | // This is an alias for RAW_SENSOR in L and replaces it in M. |
| 218 | case HAL_PIXEL_FORMAT_RAW16: |
| 219 | return "RAW16"; |
| 220 | case HAL_PIXEL_FORMAT_RAW10: |
| 221 | return "RAW10"; |
Chia-I Wu | bd4137e | 2018-03-13 17:19:54 +0000 | [diff] [blame] | 222 | case HAL_PIXEL_FORMAT_YCbCr_444_888: |
| 223 | return "YCbCr_444_888"; |
| 224 | case HAL_PIXEL_FORMAT_YCbCr_422_888: |
| 225 | return "YCbCr_422_888"; |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 226 | case HAL_PIXEL_FORMAT_RAW12: |
| 227 | return "RAW12"; |
Chia-I Wu | bd4137e | 2018-03-13 17:19:54 +0000 | [diff] [blame] | 228 | case HAL_PIXEL_FORMAT_FLEX_RGBA_8888: |
| 229 | return "FLEX_RGBA_8888"; |
| 230 | case HAL_PIXEL_FORMAT_FLEX_RGB_888: |
| 231 | return "FLEX_RGB_888"; |
Greg Hartman | 21288ad | 2018-04-17 17:51:25 -0700 | [diff] [blame] | 232 | case HAL_PIXEL_FORMAT_RGBA_FP16: |
| 233 | return "RGBA_FP16"; |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 234 | } |
| 235 | return "UNKNOWN"; |
| 236 | } |
| 237 | |
| 238 | |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 239 | static inline void formatToYcbcr( |
| 240 | int format, int width, int height, void* base_v, android_ycbcr* out) { |
| 241 | char* it = static_cast<char*>(base_v); |
| 242 | // Clear reserved fields; |
| 243 | memset(out, 0, sizeof(*out)); |
| 244 | switch (format) { |
| 245 | case HAL_PIXEL_FORMAT_YV12: |
| 246 | #ifdef GRALLOC_MODULE_API_VERSION_0_2 |
| 247 | case HAL_PIXEL_FORMAT_YCbCr_420_888: |
| 248 | #endif |
Jorge E. Moreira | 7df268b | 2019-04-05 17:51:30 -0700 | [diff] [blame] | 249 | out->ystride = vsoc::screen::ScreenRegionView::align(width); |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 250 | out->cstride = |
Jorge E. Moreira | 7df268b | 2019-04-05 17:51:30 -0700 | [diff] [blame] | 251 | vsoc::screen::ScreenRegionView::align(out->ystride / 2); |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 252 | out->chroma_step = 1; |
| 253 | out->y = it; |
| 254 | it += out->ystride * height; |
| 255 | out->cr = it; |
| 256 | it += out->cstride * height / 2; |
| 257 | out->cb = it; |
| 258 | break; |
| 259 | default: |
| 260 | ALOGE("%s: can't deal with format=0x%x (%s)", |
| 261 | __FUNCTION__, format, pixel_format_to_string(format)); |
| 262 | } |
| 263 | } |
| 264 | |
| 265 | static inline int formatToBytesPerFrame(int format, int w, int h) { |
| 266 | int bytes_per_pixel = formatToBytesPerPixel(format); |
| 267 | int w16, h16; |
| 268 | int y_size, c_size; |
| 269 | |
| 270 | switch (format) { |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 271 | // BLOB is used to allocate buffers for JPEG formatted data. Bytes per pixel |
| 272 | // is 1, the desired buffer size is in w, and h should be 1. We refrain from |
| 273 | // adding additional padding, although the caller is likely to round |
| 274 | // up to a page size. |
| 275 | case HAL_PIXEL_FORMAT_BLOB: |
| 276 | return bytes_per_pixel * w * h; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 277 | case HAL_PIXEL_FORMAT_YV12: |
| 278 | #ifdef GRALLOC_MODULE_API_VERSION_0_2 |
| 279 | case HAL_PIXEL_FORMAT_YCbCr_420_888: |
| 280 | #endif |
| 281 | android_ycbcr strides; |
| 282 | formatToYcbcr(format, w, h, NULL, &strides); |
| 283 | y_size = strides.ystride * h; |
| 284 | c_size = strides.cstride * h / 2; |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 285 | return (y_size + 2 * c_size + |
Jorge E. Moreira | 57919e8 | 2018-02-13 11:50:34 -0800 | [diff] [blame] | 286 | vsoc::screen::ScreenRegionView::kSwiftShaderPadding); |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 287 | /*case HAL_PIXEL_FORMAT_RGBA_8888: |
| 288 | case HAL_PIXEL_FORMAT_RGBX_8888: |
| 289 | case HAL_PIXEL_FORMAT_BGRA_8888: |
| 290 | case HAL_PIXEL_FORMAT_RGB_888: |
| 291 | case HAL_PIXEL_FORMAT_RGB_565:*/ |
| 292 | default: |
Jorge E. Moreira | 7df268b | 2019-04-05 17:51:30 -0700 | [diff] [blame] | 293 | w16 = vsoc::screen::ScreenRegionView::align(w); |
| 294 | h16 = vsoc::screen::ScreenRegionView::align(h); |
Jorge E. Moreira | 9334f3d | 2018-01-23 14:55:00 -0800 | [diff] [blame] | 295 | return bytes_per_pixel * w16 * h16 + |
Jorge E. Moreira | 57919e8 | 2018-02-13 11:50:34 -0800 | [diff] [blame] | 296 | vsoc::screen::ScreenRegionView::kSwiftShaderPadding; |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 297 | } |
| 298 | } |
| 299 | |
Cody Schuffelen | 134ff03 | 2019-11-22 00:25:32 -0800 | [diff] [blame^] | 300 | int fb_device_open( |
| 301 | const hw_module_t* module, const char* name, hw_device_t** device); |
| 302 | |
Jorge E. Moreira | e201723 | 2017-11-06 15:51:40 -0800 | [diff] [blame] | 303 | int gralloc_lock( |
| 304 | gralloc_module_t const* module, |
| 305 | buffer_handle_t handle, int usage, |
| 306 | int l, int t, int w, int h, |
| 307 | void** vaddr); |
| 308 | |
| 309 | int gralloc_unlock( |
| 310 | gralloc_module_t const* module, buffer_handle_t handle); |
| 311 | |
| 312 | int gralloc_register_buffer( |
| 313 | gralloc_module_t const* module, buffer_handle_t handle); |
| 314 | |
| 315 | int gralloc_unregister_buffer( |
| 316 | gralloc_module_t const* module, buffer_handle_t handle); |
| 317 | |
| 318 | int gralloc_lock_ycbcr( |
| 319 | struct gralloc_module_t const* module, |
| 320 | buffer_handle_t handle, int usage, |
| 321 | int l, int t, int w, int h, |
| 322 | struct android_ycbcr *ycbcr); |
Jason Macnak | 2bc6b69 | 2019-09-27 09:35:59 -0700 | [diff] [blame] | 323 | |
| 324 | int32_t gralloc_get_transport_size( |
| 325 | struct gralloc_module_t const* module, buffer_handle_t handle, |
| 326 | uint32_t *outNumFds, uint32_t *outNumInts); |
| 327 | |
| 328 | int32_t gralloc_validate_buffer_size( |
| 329 | struct gralloc_module_t const* device, buffer_handle_t handle, |
| 330 | uint32_t w, uint32_t h, int32_t format, int usage, |
| 331 | uint32_t stride); |