os/android/utils_android.h

   1
   2 /*
   3 // Copyright (c) 2017 Intel Corporation
   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
  18 #ifndef OS_UTILS_ANDROID_H_
  19 #define OS_UTILS_ANDROID_H_
  20
  21 #include <xf86drmMode.h>
  22 #include <xf86drm.h>
  23
  24 #include <stdint.h>
  25 #include <drm_fourcc.h>
  26 #include <system/graphics.h>
  27
  28 #include "platformdefines.h"
  29
  30 #ifdef USE_MINIGBM
  31 #include <cros_gralloc_handle.h>
  32 #include <cros_gralloc_helpers.h>
  33 #endif
  34
  35 #include <hwcdefs.h>
  36 #include "hwcbuffer.h"
  37 #include "hwctrace.h"
  38
  39 #define HWC_UNUSED(x) ((void)&(x))
  40
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 #define DRV_MAX_PLANES 4
  46
  47 // Conversion from HAL to fourcc-based DRM formats
  48 static uint32_t GetDrmFormatFromHALFormat(int format) {
  49   switch (format) {
  50     case HAL_PIXEL_FORMAT_RGBA_8888:
  51       return DRM_FORMAT_BGRA8888;
  52     case HAL_PIXEL_FORMAT_RGBX_8888:
  53       return DRM_FORMAT_BGRX8888;
  54     case HAL_PIXEL_FORMAT_RGB_888:
  55       return DRM_FORMAT_BGR888;
  56     case HAL_PIXEL_FORMAT_RGB_565:
  57       return DRM_FORMAT_BGR565;
  58     case HAL_PIXEL_FORMAT_BGRA_8888:
  59       return DRM_FORMAT_ARGB8888;
  60     case HAL_PIXEL_FORMAT_YV12:
  61       return DRM_FORMAT_YVU420;
  62     default:
  63       break;
  64   }
  65
  66   return DRM_FORMAT_NONE;
  67 }
  68
  69 static uint32_t DrmFormatToHALFormat(int format) {
  70   switch (format) {
  71     case DRM_FORMAT_BGRA8888:
  72       return HAL_PIXEL_FORMAT_RGBA_8888;
  73     case DRM_FORMAT_BGRX8888:
  74       return HAL_PIXEL_FORMAT_RGBX_8888;
  75     case DRM_FORMAT_BGR888:
  76       return HAL_PIXEL_FORMAT_RGB_888;
  77     case DRM_FORMAT_BGR565:
  78       return HAL_PIXEL_FORMAT_RGB_565;
  79     case DRM_FORMAT_ARGB8888:
  80       return HAL_PIXEL_FORMAT_BGRA_8888;
  81     case DRM_FORMAT_YVU420:
  82       return HAL_PIXEL_FORMAT_YV12;
  83     case DRM_FORMAT_R8:
  84       return HAL_PIXEL_FORMAT_BLOB;
  85     case DRM_FORMAT_GR88:
  86     case DRM_FORMAT_R16:
  87       return HAL_PIXEL_FORMAT_Y16;
  88     case DRM_FORMAT_RGB332:  //('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
  89       return 0;
  90     case DRM_FORMAT_BGR233:  //('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
  91       return 0;
  92
  93     case DRM_FORMAT_XRGB4444:
  94     case DRM_FORMAT_XBGR4444:
  95     case DRM_FORMAT_RGBX4444:
  96     case DRM_FORMAT_BGRX4444:
  97     case DRM_FORMAT_ARGB4444:
  98     case DRM_FORMAT_ABGR4444:
  99     case DRM_FORMAT_RGBA4444:
 100     case DRM_FORMAT_BGRA4444:
 101       return 0;
 102     case DRM_FORMAT_XRGB1555:
 103     case DRM_FORMAT_XBGR1555:
 104     case DRM_FORMAT_RGBX5551:
 105     case DRM_FORMAT_BGRX5551:
 106     case DRM_FORMAT_ARGB1555:
 107     case DRM_FORMAT_ABGR1555:
 108     case DRM_FORMAT_RGBA5551:
 109     case DRM_FORMAT_BGRA5551:
 110       return 0;
 111     case DRM_FORMAT_RGB565:
 112       return HAL_PIXEL_FORMAT_RGB_565;
 113     case DRM_FORMAT_RGB888:
 114       return HAL_PIXEL_FORMAT_RGB_888;
 115     case DRM_FORMAT_XRGB8888:
 116     case DRM_FORMAT_XBGR8888:
 117     case DRM_FORMAT_RGBX8888:
 118     case DRM_FORMAT_ABGR8888:
 119     case DRM_FORMAT_RGBA8888:
 120       return 0;
 121     case DRM_FORMAT_XRGB2101010:
 122     case DRM_FORMAT_XBGR2101010:
 123     case DRM_FORMAT_RGBX1010102:
 124     case DRM_FORMAT_BGRX1010102:
 125     case DRM_FORMAT_ARGB2101010:
 126     case DRM_FORMAT_ABGR2101010:
 127     case DRM_FORMAT_RGBA1010102:
 128     case DRM_FORMAT_BGRA1010102:
 129       return 0;
 130     case DRM_FORMAT_YUYV:
 131       return HAL_PIXEL_FORMAT_YCbCr_422_I;
 132     case DRM_FORMAT_YVYU:
 133     case DRM_FORMAT_UYVY:
 134     case DRM_FORMAT_VYUY:
 135     case DRM_FORMAT_AYUV:
 136       return 0;
 137 #ifdef USE_MINIGBM
 138     case DRM_FORMAT_NV12:
 139       return HAL_PIXEL_FORMAT_NV12;
 140 #endif
 141     case DRM_FORMAT_NV21:
 142       return HAL_PIXEL_FORMAT_YCrCb_420_SP;
 143     case DRM_FORMAT_NV16:
 144       return HAL_PIXEL_FORMAT_YCbCr_422_SP;
 145     case DRM_FORMAT_NV61:
 146     case DRM_FORMAT_YUV410:
 147     case DRM_FORMAT_YVU410:
 148     case DRM_FORMAT_YUV411:
 149     case DRM_FORMAT_YVU411:
 150       return 0;
 151     case DRM_FORMAT_YUV420:
 152       return HAL_PIXEL_FORMAT_YCbCr_420_888;
 153     case DRM_FORMAT_YVU420_ANDROID:
 154       return HAL_PIXEL_FORMAT_YV12;
 155     case DRM_FORMAT_YUV422:
 156       return HAL_PIXEL_FORMAT_YCbCr_422_888;
 157     case DRM_FORMAT_YVU422:
 158       return 0;
 159     case DRM_FORMAT_YUV444:
 160       return HAL_PIXEL_FORMAT_YCbCr_444_888;
 161     case DRM_FORMAT_YVU444:
 162       return 0;
 163 #ifdef USE_MINIGBM
 164     case DRM_FORMAT_NV12_Y_TILED_INTEL:
 165       return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
 166 #endif
 167     case DRM_FORMAT_P010:
 168       return HAL_PIXEL_FORMAT_P010_INTEL;
 169     default:
 170       return 0;
 171       break;
 172   }
 173
 174   return DRM_FORMAT_NONE;
 175 }
 176
 177 static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
 178   native_handle_t *new_handle =
 179       native_handle_create(handle->numFds, handle->numInts);
 180   if (new_handle == NULL)
 181     return NULL;
 182
 183   const int *old_data = handle->data;
 184   int *new_data = new_handle->data;
 185   for (int i = 0; i < handle->numFds; i++) {
 186     *new_data = dup(*old_data);
 187     old_data++;
 188     new_data++;
 189   }
 190   memcpy(new_data, old_data, sizeof(int) * handle->numInts);
 191
 192   return new_handle;
 193 }
 194
 195 static void free_buffer_handle(native_handle_t *handle) {
 196   int ret = native_handle_close(handle);
 197   if (ret)
 198     ETRACE("Failed to close native handle %d", ret);
 199   ret = native_handle_delete(handle);
 200   if (ret)
 201     ETRACE("Failed to delete native handle %d", ret);
 202 }
 203
 204 static void CopyBufferHandle(HWCNativeHandle source, HWCNativeHandle *target) {
 205   struct gralloc_handle *temp = new struct gralloc_handle();
 206   temp->handle_ = source->handle_;
 207   temp->buffer_ = source->buffer_;
 208   temp->imported_handle_ = dup_buffer_handle(source->handle_);
 209   temp->hwc_buffer_ = source->hwc_buffer_;
 210   *target = temp;
 211 }
 212
 213 static void DestroyBufferHandle(HWCNativeHandle handle) {
 214   if (handle->imported_handle_)
 215     free_buffer_handle(handle->imported_handle_);
 216
 217   delete handle;
 218   handle = NULL;
 219 }
 220 #ifdef USE_MINIGBM
 221 static bool CreateGraphicsBuffer(uint32_t w, uint32_t h, int format,
 222                                  HWCNativeHandle *handle, uint32_t layer_type) {
 223   struct gralloc_handle *temp = new struct gralloc_handle();
 224   uint32_t usage = 0;
 225   uint32_t pixel_format = 0;
 226   if (format != 0) {
 227     pixel_format = DrmFormatToHALFormat(format);
 228   }
 229
 230   if (pixel_format == 0) {
 231     pixel_format = android::PIXEL_FORMAT_RGBA_8888;
 232   }
 233
 234   if (layer_type == hwcomposer::kLayerNormal) {
 235     usage |= GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_RENDER |
 236              GRALLOC_USAGE_HW_COMPOSER;
 237   } else if (layer_type == hwcomposer::kLayerVideo) {
 238     switch (pixel_format) {
 239       case HAL_PIXEL_FORMAT_YCbCr_422_I:
 240       case HAL_PIXEL_FORMAT_Y8:
 241         usage |= GRALLOC_USAGE_HW_TEXTURE;
 242         break;
 243       default:
 244         usage |= GRALLOC_USAGE_HW_CAMERA_WRITE | GRALLOC_USAGE_HW_CAMERA_READ |
 245                  GRALLOC_USAGE_HW_TEXTURE;
 246     }
 247   } else if (layer_type == hwcomposer::kLayerCursor) {
 248     usage |= GRALLOC_USAGE_CURSOR;
 249   }
 250
 251   temp->buffer_ = new android::GraphicBuffer(w, h, pixel_format, usage);
 252   temp->handle_ = temp->buffer_->handle;
 253   temp->hwc_buffer_ = true;
 254   *handle = temp;
 255
 256   return true;
 257 }
 258
 259 static bool ReleaseGraphicsBuffer(HWCNativeHandle handle, int fd) {
 260   if (!handle)
 261     return false;
 262
 263   if (handle->buffer_.get() && handle->hwc_buffer_) {
 264     handle->buffer_.clear();
 265   }
 266
 267   if (handle->gem_handle_ > 0) {
 268     struct drm_gem_close gem_close;
 269     memset(&gem_close, 0, sizeof(gem_close));
 270     gem_close.handle = handle->gem_handle_;
 271     int ret = drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
 272     if (ret)
 273       ETRACE("Failed to close gem handle %d", ret);
 274   }
 275
 276   handle->gem_handle_ = 0;
 277
 278   return true;
 279 }
 280
 281 static bool ImportGraphicsBuffer(HWCNativeHandle handle, HwcBuffer *bo,
 282                                  int fd) {
 283   auto gr_handle = (struct cros_gralloc_handle *)handle->imported_handle_;
 284   memset(bo, 0, sizeof(struct HwcBuffer));
 285   bo->format = gr_handle->format;
 286   bo->width = gr_handle->width;
 287   bo->height = gr_handle->height;
 288   bo->prime_fd = gr_handle->fds[0];
 289
 290   uint32_t id = 0;
 291   if (drmPrimeFDToHandle(fd, bo->prime_fd, &id)) {
 292     ETRACE("drmPrimeFDToHandle failed. %s", PRINTERROR());
 293     return false;
 294   }
 295
 296   for (size_t p = 0; p < DRV_MAX_PLANES; p++) {
 297     bo->offsets[p] = gr_handle->offsets[p];
 298     bo->pitches[p] = gr_handle->strides[p];
 299     bo->gem_handles[p] = id;
 300   }
 301
 302   if (gr_handle->usage & GRALLOC_USAGE_PROTECTED) {
 303     bo->usage |= hwcomposer::kLayerProtected;
 304   } else if (gr_handle->usage & GRALLOC_USAGE_CURSOR) {
 305     bo->usage |= hwcomposer::kLayerCursor;
 306     // We support DRM_FORMAT_ARGB8888 for cursor.
 307     bo->format = DRM_FORMAT_ARGB8888;
 308   } else {
 309     bo->usage |= hwcomposer::kLayerNormal;
 310   }
 311
 312   handle->gem_handle_ = id;
 313
 314   // switch minigbm specific enum to a standard one
 315   if (bo->format == DRM_FORMAT_YVU420_ANDROID)
 316     bo->format = DRM_FORMAT_YVU420;
 317
 318   return true;
 319 }
 320 #endif
 321 #ifdef __cplusplus
 322 }
 323 #endif
 324 #endif