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 <sys/cdefs.h> 20 #include <sys/mman.h> 21 #include <hardware/gralloc.h> 22 #include <errno.h> 23 #include <unistd.h> 24 #include <string.h> 25 26 #include <cutils/native_handle.h> 27 #include <cutils/log.h> 28 29 #include <linux/fb.h> 30 31 #include "common/vsoc/lib/screen_region_view.h" 32 #include "guest/libs/platform_support/api_level_fixes.h" 33 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; 54 }; 55 56 /*****************************************************************************/ 57 58 struct priv_alloc_device_t { 59 alloc_device_t device; 60 }; 61 62 /*****************************************************************************/ 63 64 struct private_handle_t : public native_handle { 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; 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); 146 return -EINVAL; 147 } 148 return 0; 149 } 150 }; 151 152 153 static inline int formatToBytesPerPixel(int format) { 154 switch (format) { 155 #if VSOC_PLATFORM_SDK_AFTER(N_MR1) 156 case HAL_PIXEL_FORMAT_RGBA_FP16: 157 return 8; 158 #endif 159 case HAL_PIXEL_FORMAT_RGBA_8888: 160 case HAL_PIXEL_FORMAT_RGBX_8888: 161 case HAL_PIXEL_FORMAT_BGRA_8888: 162 #if VSOC_PLATFORM_SDK_AFTER(J) 163 // The camera 3.0 implementation assumes that IMPLEMENTATION_DEFINED 164 // means HAL_PIXEL_FORMAT_RGBA_8888 165 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 166 #endif 167 return 4; 168 case HAL_PIXEL_FORMAT_RGB_888: 169 return 3; 170 case HAL_PIXEL_FORMAT_RGB_565: 171 case HAL_PIXEL_FORMAT_YV12: 172 #ifdef GRALLOC_MODULE_API_VERSION_0_2 173 case HAL_PIXEL_FORMAT_YCbCr_420_888: 174 #endif 175 return 2; 176 #if VSOC_PLATFORM_SDK_AFTER(J) 177 case HAL_PIXEL_FORMAT_BLOB: 178 return 1; 179 #endif 180 default: 181 ALOGE("%s: unknown format=%d", __FUNCTION__, format); 182 return 8; 183 } 184 } 185 186 inline const char* pixel_format_to_string(int format) { 187 switch (format) { 188 // Formats that are universal across versions 189 case HAL_PIXEL_FORMAT_RGBA_8888: 190 return "RGBA_8888"; 191 case HAL_PIXEL_FORMAT_RGBX_8888: 192 return "RGBX_8888"; 193 case HAL_PIXEL_FORMAT_BGRA_8888: 194 return "BGRA_8888"; 195 case HAL_PIXEL_FORMAT_RGB_888: 196 return "RGB_888"; 197 case HAL_PIXEL_FORMAT_RGB_565: 198 return "RGB_565"; 199 case HAL_PIXEL_FORMAT_YV12: 200 return "YV12"; 201 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 202 return "YCrCb_420_SP"; 203 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 204 return "YCbCr_422_SP"; 205 case HAL_PIXEL_FORMAT_YCbCr_422_I: 206 return "YCbCr_422_I"; 207 208 #if VSOC_PLATFORM_SDK_AFTER(J) 209 // First supported on JBMR1 (API 17) 210 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 211 return "IMPLEMENTATION_DEFINED"; 212 case HAL_PIXEL_FORMAT_BLOB: 213 return "BLOB"; 214 #endif 215 #if VSOC_PLATFORM_SDK_AFTER(J_MR1) 216 // First supported on JBMR2 (API 18) 217 case HAL_PIXEL_FORMAT_YCbCr_420_888: 218 return "YCbCr_420_888"; 219 case HAL_PIXEL_FORMAT_Y8: 220 return "Y8"; 221 case HAL_PIXEL_FORMAT_Y16: 222 return "Y16"; 223 #endif 224 #if VSOC_PLATFORM_SDK_AFTER(K) 225 // Support was added in L (API 21) 226 case HAL_PIXEL_FORMAT_RAW_OPAQUE: 227 return "RAW_OPAQUE"; 228 // This is an alias for RAW_SENSOR in L and replaces it in M. 229 case HAL_PIXEL_FORMAT_RAW16: 230 return "RAW16"; 231 case HAL_PIXEL_FORMAT_RAW10: 232 return "RAW10"; 233 #endif 234 #if VSOC_PLATFORM_SDK_AFTER(L_MR1) 235 case HAL_PIXEL_FORMAT_YCbCr_444_888: 236 return "YCbCr_444_888"; 237 case HAL_PIXEL_FORMAT_YCbCr_422_888: 238 return "YCbCr_422_888"; 239 case HAL_PIXEL_FORMAT_RAW12: 240 return "RAW12"; 241 case HAL_PIXEL_FORMAT_FLEX_RGBA_8888: 242 return "FLEX_RGBA_8888"; 243 case HAL_PIXEL_FORMAT_FLEX_RGB_888: 244 return "FLEX_RGB_888"; 245 #endif 246 #if VSOC_PLATFORM_SDK_AFTER(N_MR1) 247 case HAL_PIXEL_FORMAT_RGBA_FP16: 248 return "RGBA_FP16"; 249 #endif 250 251 // Formats that have been removed 252 #if VSOC_PLATFORM_SDK_BEFORE(K) 253 // Support was dropped on K (API 19) 254 case HAL_PIXEL_FORMAT_RGBA_5551: 255 return "RGBA_5551"; 256 case HAL_PIXEL_FORMAT_RGBA_4444: 257 return "RGBA_4444"; 258 #endif 259 #if VSOC_PLATFORM_SDK_BEFORE(L) 260 // Renamed to RAW_16 in L. Both were present for L, but it was completely 261 // removed in M. 262 case HAL_PIXEL_FORMAT_RAW_SENSOR: 263 return "RAW_SENSOR"; 264 #endif 265 #if VSOC_PLATFORM_SDK_AFTER(J_MR2) && VSOC_PLATFORM_SDK_BEFORE(M) 266 // Supported K, L, and LMR1. Not supported on JBMR0, JBMR1, JBMR2, and M 267 case HAL_PIXEL_FORMAT_sRGB_X_8888: 268 return "sRGB_X_8888"; 269 case HAL_PIXEL_FORMAT_sRGB_A_8888: 270 return "sRGB_A_8888"; 271 #endif 272 } 273 return "UNKNOWN"; 274 } 275 276 277 static inline void formatToYcbcr( 278 int format, int width, int height, void* base_v, android_ycbcr* out) { 279 char* it = static_cast<char*>(base_v); 280 // Clear reserved fields; 281 memset(out, 0, sizeof(*out)); 282 switch (format) { 283 case HAL_PIXEL_FORMAT_YV12: 284 #ifdef GRALLOC_MODULE_API_VERSION_0_2 285 case HAL_PIXEL_FORMAT_YCbCr_420_888: 286 #endif 287 out->ystride = vsoc::screen::ScreenRegionView::align(width, 16); 288 out->cstride = 289 vsoc::screen::ScreenRegionView::align(out->ystride / 2, 16); 290 out->chroma_step = 1; 291 out->y = it; 292 it += out->ystride * height; 293 out->cr = it; 294 it += out->cstride * height / 2; 295 out->cb = it; 296 break; 297 default: 298 ALOGE("%s: can't deal with format=0x%x (%s)", 299 __FUNCTION__, format, pixel_format_to_string(format)); 300 } 301 } 302 303 static inline int formatToBytesPerFrame(int format, int w, int h) { 304 int bytes_per_pixel = formatToBytesPerPixel(format); 305 int w16, h16; 306 int y_size, c_size; 307 308 switch (format) { 309 #if VSOC_PLATFORM_SDK_AFTER(J) 310 // BLOB is used to allocate buffers for JPEG formatted data. Bytes per pixel 311 // is 1, the desired buffer size is in w, and h should be 1. We refrain from 312 // adding additional padding, although the caller is likely to round 313 // up to a page size. 314 case HAL_PIXEL_FORMAT_BLOB: 315 return bytes_per_pixel * w * h; 316 #endif 317 case HAL_PIXEL_FORMAT_YV12: 318 #ifdef GRALLOC_MODULE_API_VERSION_0_2 319 case HAL_PIXEL_FORMAT_YCbCr_420_888: 320 #endif 321 android_ycbcr strides; 322 formatToYcbcr(format, w, h, NULL, &strides); 323 y_size = strides.ystride * h; 324 c_size = strides.cstride * h / 2; 325 return (y_size + 2 * c_size + 326 vsoc::screen::ScreenRegionView::kSwiftShaderPadding); 327 /*case HAL_PIXEL_FORMAT_RGBA_8888: 328 case HAL_PIXEL_FORMAT_RGBX_8888: 329 case HAL_PIXEL_FORMAT_BGRA_8888: 330 case HAL_PIXEL_FORMAT_RGB_888: 331 case HAL_PIXEL_FORMAT_RGB_565:*/ 332 default: 333 w16 = vsoc::screen::ScreenRegionView::align(w, 16); 334 h16 = vsoc::screen::ScreenRegionView::align(h, 16); 335 return bytes_per_pixel * w16 * h16 + 336 vsoc::screen::ScreenRegionView::kSwiftShaderPadding; 337 } 338 } 339 340 int fb_device_open( 341 const hw_module_t* module, const char* name, hw_device_t** device); 342 343 int gralloc_lock( 344 gralloc_module_t const* module, 345 buffer_handle_t handle, int usage, 346 int l, int t, int w, int h, 347 void** vaddr); 348 349 int gralloc_unlock( 350 gralloc_module_t const* module, buffer_handle_t handle); 351 352 int gralloc_register_buffer( 353 gralloc_module_t const* module, buffer_handle_t handle); 354 355 int gralloc_unregister_buffer( 356 gralloc_module_t const* module, buffer_handle_t handle); 357 358 int gralloc_lock_ycbcr( 359 struct gralloc_module_t const* module, 360 buffer_handle_t handle, int usage, 361 int l, int t, int w, int h, 362 struct android_ycbcr *ycbcr); 363
