helpers.c

   1 /*
   2  * Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
   3  * Use of this source code is governed by a BSD-style license that can be
   4  * found in the LICENSE file.
   5  */
   6
   7 #include <assert.h>
   8 #include <stdbool.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <xf86drm.h>
  13
  14 #include "gbm_priv.h"
  15 #include "helpers.h"
  16 #include "util.h"
  17
  18 size_t gbm_num_planes_from_format(uint32_t format)
  19 {
  20         if (format == GBM_BO_FORMAT_XRGB8888)
  21                 format = GBM_FORMAT_XRGB8888;
  22         if (format == GBM_BO_FORMAT_ARGB8888)
  23                 format = GBM_FORMAT_ARGB8888;
  24
  25         switch(format)
  26         {
  27                 case GBM_FORMAT_C8:
  28                 case GBM_FORMAT_R8:
  29                 case GBM_FORMAT_RG88:
  30                 case GBM_FORMAT_GR88:
  31                 case GBM_FORMAT_RGB332:
  32                 case GBM_FORMAT_BGR233:
  33                 case GBM_FORMAT_XRGB4444:
  34                 case GBM_FORMAT_XBGR4444:
  35                 case GBM_FORMAT_RGBX4444:
  36                 case GBM_FORMAT_BGRX4444:
  37                 case GBM_FORMAT_ARGB4444:
  38                 case GBM_FORMAT_ABGR4444:
  39                 case GBM_FORMAT_RGBA4444:
  40                 case GBM_FORMAT_BGRA4444:
  41                 case GBM_FORMAT_XRGB1555:
  42                 case GBM_FORMAT_XBGR1555:
  43                 case GBM_FORMAT_RGBX5551:
  44                 case GBM_FORMAT_BGRX5551:
  45                 case GBM_FORMAT_ARGB1555:
  46                 case GBM_FORMAT_ABGR1555:
  47                 case GBM_FORMAT_RGBA5551:
  48                 case GBM_FORMAT_BGRA5551:
  49                 case GBM_FORMAT_RGB565:
  50                 case GBM_FORMAT_BGR565:
  51                 case GBM_FORMAT_YUYV:
  52                 case GBM_FORMAT_YVYU:
  53                 case GBM_FORMAT_UYVY:
  54                 case GBM_FORMAT_VYUY:
  55                 case GBM_FORMAT_RGB888:
  56                 case GBM_FORMAT_BGR888:
  57                 case GBM_FORMAT_XRGB8888:
  58                 case GBM_FORMAT_XBGR8888:
  59                 case GBM_FORMAT_RGBX8888:
  60                 case GBM_FORMAT_BGRX8888:
  61                 case GBM_FORMAT_ARGB8888:
  62                 case GBM_FORMAT_ABGR8888:
  63                 case GBM_FORMAT_RGBA8888:
  64                 case GBM_FORMAT_BGRA8888:
  65                 case GBM_FORMAT_XRGB2101010:
  66                 case GBM_FORMAT_XBGR2101010:
  67                 case GBM_FORMAT_RGBX1010102:
  68                 case GBM_FORMAT_BGRX1010102:
  69                 case GBM_FORMAT_ARGB2101010:
  70                 case GBM_FORMAT_ABGR2101010:
  71                 case GBM_FORMAT_RGBA1010102:
  72                 case GBM_FORMAT_BGRA1010102:
  73                 case GBM_FORMAT_AYUV:
  74                         return 1;
  75                 case GBM_FORMAT_NV12:
  76                         return 2;
  77         }
  78
  79         fprintf(stderr, "minigbm: UNKNOWN FORMAT %d\n", format);
  80         return 0;
  81 }
  82
  83 int gbm_bpp_from_format(uint32_t format)
  84 {
  85         if (format == GBM_BO_FORMAT_XRGB8888)
  86                 format = GBM_FORMAT_XRGB8888;
  87         if (format == GBM_BO_FORMAT_ARGB8888)
  88                 format = GBM_FORMAT_ARGB8888;
  89
  90         switch(format)
  91         {
  92                 case GBM_FORMAT_C8:
  93                 case GBM_FORMAT_R8:
  94                 case GBM_FORMAT_RGB332:
  95                 case GBM_FORMAT_BGR233:
  96                         return 8;
  97
  98                 case GBM_FORMAT_NV12:
  99                         return 12;
 100
 101                 case GBM_FORMAT_RG88:
 102                 case GBM_FORMAT_GR88:
 103                 case GBM_FORMAT_XRGB4444:
 104                 case GBM_FORMAT_XBGR4444:
 105                 case GBM_FORMAT_RGBX4444:
 106                 case GBM_FORMAT_BGRX4444:
 107                 case GBM_FORMAT_ARGB4444:
 108                 case GBM_FORMAT_ABGR4444:
 109                 case GBM_FORMAT_RGBA4444:
 110                 case GBM_FORMAT_BGRA4444:
 111                 case GBM_FORMAT_XRGB1555:
 112                 case GBM_FORMAT_XBGR1555:
 113                 case GBM_FORMAT_RGBX5551:
 114                 case GBM_FORMAT_BGRX5551:
 115                 case GBM_FORMAT_ARGB1555:
 116                 case GBM_FORMAT_ABGR1555:
 117                 case GBM_FORMAT_RGBA5551:
 118                 case GBM_FORMAT_BGRA5551:
 119                 case GBM_FORMAT_RGB565:
 120                 case GBM_FORMAT_BGR565:
 121                 case GBM_FORMAT_YUYV:
 122                 case GBM_FORMAT_YVYU:
 123                 case GBM_FORMAT_UYVY:
 124                 case GBM_FORMAT_VYUY:
 125                         return 16;
 126
 127                 case GBM_FORMAT_RGB888:
 128                 case GBM_FORMAT_BGR888:
 129                         return 24;
 130
 131                 case GBM_FORMAT_XRGB8888:
 132                 case GBM_FORMAT_XBGR8888:
 133                 case GBM_FORMAT_RGBX8888:
 134                 case GBM_FORMAT_BGRX8888:
 135                 case GBM_FORMAT_ARGB8888:
 136                 case GBM_FORMAT_ABGR8888:
 137                 case GBM_FORMAT_RGBA8888:
 138                 case GBM_FORMAT_BGRA8888:
 139                 case GBM_FORMAT_XRGB2101010:
 140                 case GBM_FORMAT_XBGR2101010:
 141                 case GBM_FORMAT_RGBX1010102:
 142                 case GBM_FORMAT_BGRX1010102:
 143                 case GBM_FORMAT_ARGB2101010:
 144                 case GBM_FORMAT_ABGR2101010:
 145                 case GBM_FORMAT_RGBA1010102:
 146                 case GBM_FORMAT_BGRA1010102:
 147                 case GBM_FORMAT_AYUV:
 148                         return 32;
 149         }
 150
 151         fprintf(stderr, "minigbm: UNKNOWN FORMAT %d\n", format);
 152         return 0;
 153 }
 154
 155 int gbm_stride_from_format(uint32_t format, uint32_t width)
 156 {
 157         /* Only single-plane formats are supported */
 158         assert(gbm_num_planes_from_format(format) == 1);
 159         return DIV_ROUND_UP(width * gbm_bpp_from_format(format), 8);
 160 }
 161
 162 int gbm_is_format_supported(struct gbm_bo *bo)
 163 {
 164         return 1;
 165 }
 166
 167 int gbm_dumb_bo_create(struct gbm_bo *bo, uint32_t width, uint32_t height,
 168                        uint32_t format, uint32_t flags)
 169 {
 170         struct drm_mode_create_dumb create_dumb;
 171         int ret;
 172
 173         /* Only single-plane formats are supported */
 174         assert(gbm_num_planes_from_format(format) == 1);
 175
 176         memset(&create_dumb, 0, sizeof(create_dumb));
 177         create_dumb.height = height;
 178         create_dumb.width = width;
 179         create_dumb.bpp = gbm_bpp_from_format(format);
 180         create_dumb.flags = 0;
 181
 182         ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
 183         if (ret) {
 184                 fprintf(stderr, "minigbm: DRM_IOCTL_MODE_CREATE_DUMB failed\n");
 185                 return ret;
 186         }
 187
 188         bo->handles[0].u32 = create_dumb.handle;
 189         bo->offsets[0] = 0;
 190         bo->sizes[0] = create_dumb.size;
 191         bo->strides[0] = create_dumb.pitch;
 192
 193         return 0;
 194 }
 195
 196 int gbm_dumb_bo_destroy(struct gbm_bo *bo)
 197 {
 198         struct drm_mode_destroy_dumb destroy_dumb;
 199         int ret;
 200
 201         memset(&destroy_dumb, 0, sizeof(destroy_dumb));
 202         destroy_dumb.handle = bo->handles[0].u32;
 203
 204         ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
 205         if (ret) {
 206                 fprintf(stderr, "minigbm: DRM_IOCTL_MODE_DESTROY_DUMB failed "
 207                                 "(handle=%x)\n", bo->handles[0].u32);
 208                 return ret;
 209         }
 210
 211         return 0;
 212 }
 213
 214 int gbm_gem_bo_destroy(struct gbm_bo *bo)
 215 {
 216         struct drm_gem_close gem_close;
 217         int ret, error = 0;
 218         size_t plane, i;
 219
 220         for (plane = 0; plane < bo->num_planes; plane++) {
 221                 bool already_closed = false;
 222                 for (i = 1; i < plane && !already_closed; i++)
 223                         if (bo->handles[i-1].u32 == bo->handles[plane].u32)
 224                                 already_closed = true;
 225                 if (already_closed)
 226                         continue;
 227
 228                 memset(&gem_close, 0, sizeof(gem_close));
 229                 gem_close.handle = bo->handles[plane].u32;
 230
 231                 ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
 232                 if (ret) {
 233                         fprintf(stderr, "minigbm: DRM_IOCTL_GEM_CLOSE failed "
 234                                         "(handle=%x) error %d\n",
 235                                         bo->handles[plane].u32, ret);
 236                         error = ret;
 237                 }
 238         }
 239
 240         return error;
 241 }