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 #include <hardware/gralloc1.h>
  28
  29 #include "platformdefines.h"
  30
  31 #include <cros_gralloc_handle.h>
  32 #include <cros_gralloc_helpers.h>
  33
  34 #include <hwcdefs.h>
  35 #include "hwctrace.h"
  36 #include "hwcutils.h"
  37
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif
  41
  42 #define DRV_MAX_PLANES 4
  43
  44 // Conversion from HAL to fourcc-based DRM formats
  45 static uint32_t GetDrmFormatFromHALFormat(int format) {
  46   switch (format) {
  47     case HAL_PIXEL_FORMAT_RGBA_8888:
  48       return DRM_FORMAT_BGRA8888;
  49     case HAL_PIXEL_FORMAT_RGBX_8888:
  50       return DRM_FORMAT_BGRX8888;
  51     case HAL_PIXEL_FORMAT_RGB_888:
  52       return DRM_FORMAT_BGR888;
  53     case HAL_PIXEL_FORMAT_RGB_565:
  54       return DRM_FORMAT_BGR565;
  55     case HAL_PIXEL_FORMAT_BGRA_8888:
  56       return DRM_FORMAT_ARGB8888;
  57     case HAL_PIXEL_FORMAT_YV12:
  58       return DRM_FORMAT_YVU420;
  59     case HAL_PIXEL_FORMAT_RGBA_FP16:
  60       return DRM_FORMAT_XBGR161616;
  61     case HAL_PIXEL_FORMAT_RGBA_1010102:
  62       return DRM_FORMAT_ABGR2101010;
  63     default:
  64       break;
  65   }
  66
  67   return DRM_FORMAT_NONE;
  68 }
  69
  70 static uint32_t DrmFormatToHALFormat(int format) {
  71   switch (format) {
  72     case DRM_FORMAT_BGRA8888:
  73       return HAL_PIXEL_FORMAT_RGBA_8888;
  74     case DRM_FORMAT_BGRX8888:
  75       return HAL_PIXEL_FORMAT_RGBX_8888;
  76     case DRM_FORMAT_BGR888:
  77       return HAL_PIXEL_FORMAT_RGB_888;
  78     case DRM_FORMAT_BGR565:
  79       return HAL_PIXEL_FORMAT_RGB_565;
  80     case DRM_FORMAT_ARGB8888:
  81       return HAL_PIXEL_FORMAT_BGRA_8888;
  82     case DRM_FORMAT_YVU420:
  83       return HAL_PIXEL_FORMAT_YV12;
  84     case DRM_FORMAT_R8:
  85       return HAL_PIXEL_FORMAT_BLOB;
  86     case DRM_FORMAT_GR88:
  87     case DRM_FORMAT_R16:
  88       return HAL_PIXEL_FORMAT_Y16;
  89     case DRM_FORMAT_ABGR8888:
  90       return HAL_PIXEL_FORMAT_RGBA_8888;
  91     case DRM_FORMAT_RGB332:  //('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
  92       return 0;
  93     case DRM_FORMAT_BGR233:  //('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
  94       return 0;
  95
  96     case DRM_FORMAT_XRGB4444:
  97     case DRM_FORMAT_XBGR4444:
  98     case DRM_FORMAT_RGBX4444:
  99     case DRM_FORMAT_BGRX4444:
 100     case DRM_FORMAT_ARGB4444:
 101     case DRM_FORMAT_ABGR4444:
 102     case DRM_FORMAT_RGBA4444:
 103     case DRM_FORMAT_BGRA4444:
 104       return 0;
 105     case DRM_FORMAT_XRGB1555:
 106     case DRM_FORMAT_XBGR1555:
 107     case DRM_FORMAT_RGBX5551:
 108     case DRM_FORMAT_BGRX5551:
 109     case DRM_FORMAT_ARGB1555:
 110     case DRM_FORMAT_ABGR1555:
 111     case DRM_FORMAT_RGBA5551:
 112     case DRM_FORMAT_BGRA5551:
 113       return 0;
 114     case DRM_FORMAT_RGB565:
 115       return HAL_PIXEL_FORMAT_RGB_565;
 116     case DRM_FORMAT_RGB888:
 117       return HAL_PIXEL_FORMAT_RGB_888;
 118     case DRM_FORMAT_XRGB8888:
 119     case DRM_FORMAT_XBGR8888:
 120     case DRM_FORMAT_RGBX8888:
 121     case DRM_FORMAT_RGBA8888:
 122       return 0;
 123     case DRM_FORMAT_ABGR2101010:
 124       return HAL_PIXEL_FORMAT_RGBA_1010102;
 125     case DRM_FORMAT_XRGB2101010:
 126     case DRM_FORMAT_XBGR2101010:
 127     case DRM_FORMAT_RGBX1010102:
 128     case DRM_FORMAT_BGRX1010102:
 129     case DRM_FORMAT_ARGB2101010:
 130     case DRM_FORMAT_RGBA1010102:
 131     case DRM_FORMAT_BGRA1010102:
 132       return 0;
 133     case DRM_FORMAT_YUYV:
 134       return HAL_PIXEL_FORMAT_YCbCr_422_I;
 135     case DRM_FORMAT_YVYU:
 136     case DRM_FORMAT_UYVY:
 137     case DRM_FORMAT_VYUY:
 138     case DRM_FORMAT_AYUV:
 139       ETRACE("YUV format using RGB buffer \n");
 140       return 0;
 141     case DRM_FORMAT_NV12:
 142       return HAL_PIXEL_FORMAT_NV12;
 143     case DRM_FORMAT_NV21:
 144       return HAL_PIXEL_FORMAT_YCrCb_420_SP;
 145     case DRM_FORMAT_NV16:
 146       return HAL_PIXEL_FORMAT_YCbCr_422_SP;
 147     case DRM_FORMAT_NV61:
 148     case DRM_FORMAT_YUV410:
 149     case DRM_FORMAT_YVU410:
 150     case DRM_FORMAT_YUV411:
 151     case DRM_FORMAT_YVU411:
 152       ETRACE("YUV format using RGB buffer \n");
 153       return 0;
 154     case DRM_FORMAT_YUV420:
 155       return HAL_PIXEL_FORMAT_YCbCr_420_888;
 156     case DRM_FORMAT_YVU420_ANDROID:
 157       return HAL_PIXEL_FORMAT_YV12;
 158     case DRM_FORMAT_YUV422:
 159       return HAL_PIXEL_FORMAT_YCbCr_422_888;
 160     case DRM_FORMAT_YVU422:
 161       ETRACE("YUV format using RGB buffer \n");
 162       return 0;
 163     case DRM_FORMAT_YUV444:
 164       return HAL_PIXEL_FORMAT_YCbCr_444_888;
 165     case DRM_FORMAT_YVU444:
 166       ETRACE("YUV format using RGB buffer \n");
 167       return 0;
 168     case DRM_FORMAT_NV12_Y_TILED_INTEL:
 169       return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
 170     case DRM_FORMAT_P010:
 171       return HAL_PIXEL_FORMAT_P010_INTEL;
 172     case DRM_FORMAT_XBGR161616:
 173       return HAL_PIXEL_FORMAT_RGBA_FP16;
 174     default:
 175       return 0;
 176       break;
 177   }
 178
 179   return DRM_FORMAT_NONE;
 180 }
 181
 182 static native_handle_t *dup_buffer_handle(buffer_handle_t handle) {
 183   native_handle_t *new_handle = native_handle_clone(handle);
 184   if(new_handle == NULL)
 185     ETRACE("failed to duplicate the handle");
 186   return new_handle;
 187 }
 188
 189 static void free_buffer_handle(native_handle_t *handle) {
 190   int ret = native_handle_close(handle);
 191   if (ret)
 192     ETRACE("Failed to close native handle %d", ret);
 193   ret = native_handle_delete(handle);
 194   if (ret)
 195     ETRACE("Failed to delete native handle %d", ret);
 196 }
 197
 198 static void CopyBufferHandle(HWCNativeHandle source, HWCNativeHandle *target) {
 199   struct gralloc_handle *temp = new struct gralloc_handle();
 200   temp->handle_ = source->handle_;
 201   temp->gralloc1_buffer_descriptor_t_ = 0;
 202   temp->imported_handle_ = dup_buffer_handle(source->handle_);
 203   temp->hwc_buffer_ = false;
 204   *target = temp;
 205 }
 206
 207 static void DestroyBufferHandle(HWCNativeHandle handle) {
 208   if (handle->imported_handle_)
 209     free_buffer_handle(handle->imported_handle_);
 210
 211   delete handle;
 212   handle = NULL;
 213 }
 214
 215 static bool ImportGraphicsBuffer(HWCNativeHandle handle, int fd) {
 216   auto gr_handle = (struct cros_gralloc_handle *)handle->imported_handle_;
 217   memset(&(handle->meta_data_), 0, sizeof(struct HwcBuffer));
 218   handle->meta_data_.format_ = gr_handle->format;
 219   handle->meta_data_.tiling_mode_ = gr_handle->tiling_mode;
 220   handle->meta_data_.width_ = gr_handle->width;
 221   handle->meta_data_.height_ = gr_handle->height;
 222   handle->meta_data_.native_format_ = gr_handle->droid_format;
 223
 224   int32_t numplanes = gr_handle->base.numFds;
 225   handle->meta_data_.num_planes_ = numplanes;
 226
 227   for (int32_t p = 0; p < numplanes; p++) {
 228     handle->meta_data_.offsets_[p] = gr_handle->offsets[p];
 229     handle->meta_data_.pitches_[p] = gr_handle->strides[p];
 230     handle->meta_data_.prime_fds_[p] = gr_handle->fds[p];
 231     if (drmPrimeFDToHandle(fd, gr_handle->fds[p],
 232                            &handle->meta_data_.gem_handles_[p])) {
 233       ETRACE("drmPrimeFDToHandle failed. %s", PRINTERROR());
 234       return false;
 235     }
 236   }
 237
 238   if (gr_handle->consumer_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED) {
 239     handle->meta_data_.usage_ = hwcomposer::kLayerProtected;
 240   } else if (gr_handle->consumer_usage & GRALLOC1_CONSUMER_USAGE_CURSOR) {
 241     handle->meta_data_.usage_ = hwcomposer::kLayerCursor;
 242     // We support DRM_FORMAT_ARGB8888 for cursor.
 243     handle->meta_data_.format_ = DRM_FORMAT_ARGB8888;
 244   } else if (hwcomposer::IsSupportedMediaFormat(handle->meta_data_.format_)) {
 245     handle->meta_data_.usage_ = hwcomposer::kLayerVideo;
 246   } else {
 247     handle->meta_data_.usage_ = hwcomposer::kLayerNormal;
 248   }
 249
 250   // switch minigbm specific enum to a standard one
 251   if (handle->meta_data_.format_ == DRM_FORMAT_YVU420_ANDROID)
 252     handle->meta_data_.format_ = DRM_FORMAT_YVU420;
 253
 254   return true;
 255 }
 256 #ifdef __cplusplus
 257 }
 258 #endif
 259 #endif