tests/modetest/buffers.c

   1 /*
   2  * DRM based mode setting test program
   3  * Copyright 2008 Tungsten Graphics
   4  *   Jakob Bornecrantz <jakob@tungstengraphics.com>
   5  * Copyright 2008 Intel Corporation
   6  *   Jesse Barnes <jesse.barnes@intel.com>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  24  * IN THE SOFTWARE.
  25  */
  26
  27 #include <assert.h>
  28 #include <errno.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <sys/ioctl.h>
  34
  35 #include "drm.h"
  36 #include "drm_fourcc.h"
  37
  38 #include "libdrm_macros.h"
  39 #include "xf86drm.h"
  40 #include "xf86drmMode.h"
  41
  42 #include "buffers.h"
  43
  44 struct bo
  45 {
  46         int fd;
  47         void *ptr;
  48         uint64_t size;
  49         uint32_t pitch;
  50         uint32_t handle;
  51 };
  52
  53 /* -----------------------------------------------------------------------------
  54  * Buffers management
  55  */
  56
  57 static struct bo *
  58 bo_create_dumb(int fd, unsigned int width, unsigned int height, unsigned int bpp)
  59 {
  60         struct bo *bo;
  61         int ret;
  62
  63         bo = calloc(1, sizeof(*bo));
  64         if (bo == NULL) {
  65                 fprintf(stderr, "failed to allocate buffer object\n");
  66                 return NULL;
  67         }
  68
  69         ret = drmModeCreateDumbBuffer(fd, width, height, bpp, 0, &bo->handle,
  70                                       &bo->pitch, &bo->size);
  71         if (ret) {
  72                 fprintf(stderr, "failed to create dumb buffer: %s\n",
  73                         strerror(errno));
  74                 free(bo);
  75                 return NULL;
  76         }
  77
  78         bo->fd = fd;
  79
  80         return bo;
  81 }
  82
  83 static int bo_map(struct bo *bo, void **out)
  84 {
  85         void *map;
  86         int ret;
  87         uint64_t offset;
  88
  89         ret = drmModeMapDumbBuffer(bo->fd, bo->handle, &offset);
  90         if (ret)
  91                 return ret;
  92
  93         map = drm_mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED,
  94                        bo->fd, offset);
  95         if (map == MAP_FAILED)
  96                 return -EINVAL;
  97
  98         bo->ptr = map;
  99         *out = map;
 100
 101         return 0;
 102 }
 103
 104 static void bo_unmap(struct bo *bo)
 105 {
 106         if (!bo->ptr)
 107                 return;
 108
 109         drm_munmap(bo->ptr, bo->size);
 110         bo->ptr = NULL;
 111 }
 112
 113 struct bo *
 114 bo_create(int fd, unsigned int format,
 115           unsigned int width, unsigned int height,
 116           unsigned int handles[4], unsigned int pitches[4],
 117           unsigned int offsets[4], enum util_fill_pattern pattern)
 118 {
 119         unsigned int virtual_height;
 120         struct bo *bo;
 121         unsigned int bpp;
 122         void *planes[3] = { 0, };
 123         void *virtual;
 124         int ret;
 125
 126         switch (format) {
 127         case DRM_FORMAT_C8:
 128         case DRM_FORMAT_NV12:
 129         case DRM_FORMAT_NV21:
 130         case DRM_FORMAT_NV16:
 131         case DRM_FORMAT_NV61:
 132         case DRM_FORMAT_NV24:
 133         case DRM_FORMAT_NV42:
 134         case DRM_FORMAT_YUV420:
 135         case DRM_FORMAT_YVU420:
 136                 bpp = 8;
 137                 break;
 138
 139         case DRM_FORMAT_ARGB4444:
 140         case DRM_FORMAT_XRGB4444:
 141         case DRM_FORMAT_ABGR4444:
 142         case DRM_FORMAT_XBGR4444:
 143         case DRM_FORMAT_RGBA4444:
 144         case DRM_FORMAT_RGBX4444:
 145         case DRM_FORMAT_BGRA4444:
 146         case DRM_FORMAT_BGRX4444:
 147         case DRM_FORMAT_ARGB1555:
 148         case DRM_FORMAT_XRGB1555:
 149         case DRM_FORMAT_ABGR1555:
 150         case DRM_FORMAT_XBGR1555:
 151         case DRM_FORMAT_RGBA5551:
 152         case DRM_FORMAT_RGBX5551:
 153         case DRM_FORMAT_BGRA5551:
 154         case DRM_FORMAT_BGRX5551:
 155         case DRM_FORMAT_RGB565:
 156         case DRM_FORMAT_BGR565:
 157         case DRM_FORMAT_UYVY:
 158         case DRM_FORMAT_VYUY:
 159         case DRM_FORMAT_YUYV:
 160         case DRM_FORMAT_YVYU:
 161                 bpp = 16;
 162                 break;
 163
 164         case DRM_FORMAT_BGR888:
 165         case DRM_FORMAT_RGB888:
 166                 bpp = 24;
 167                 break;
 168
 169         case DRM_FORMAT_ARGB8888:
 170         case DRM_FORMAT_XRGB8888:
 171         case DRM_FORMAT_ABGR8888:
 172         case DRM_FORMAT_XBGR8888:
 173         case DRM_FORMAT_RGBA8888:
 174         case DRM_FORMAT_RGBX8888:
 175         case DRM_FORMAT_BGRA8888:
 176         case DRM_FORMAT_BGRX8888:
 177         case DRM_FORMAT_ARGB2101010:
 178         case DRM_FORMAT_XRGB2101010:
 179         case DRM_FORMAT_ABGR2101010:
 180         case DRM_FORMAT_XBGR2101010:
 181         case DRM_FORMAT_RGBA1010102:
 182         case DRM_FORMAT_RGBX1010102:
 183         case DRM_FORMAT_BGRA1010102:
 184         case DRM_FORMAT_BGRX1010102:
 185                 bpp = 32;
 186                 break;
 187
 188         case DRM_FORMAT_XRGB16161616F:
 189         case DRM_FORMAT_XBGR16161616F:
 190         case DRM_FORMAT_ARGB16161616F:
 191         case DRM_FORMAT_ABGR16161616F:
 192                 bpp = 64;
 193                 break;
 194
 195         default:
 196                 fprintf(stderr, "unsupported format 0x%08x\n",  format);
 197                 return NULL;
 198         }
 199
 200         switch (format) {
 201         case DRM_FORMAT_NV12:
 202         case DRM_FORMAT_NV21:
 203         case DRM_FORMAT_YUV420:
 204         case DRM_FORMAT_YVU420:
 205                 virtual_height = height * 3 / 2;
 206                 break;
 207
 208         case DRM_FORMAT_NV16:
 209         case DRM_FORMAT_NV61:
 210                 virtual_height = height * 2;
 211                 break;
 212
 213         case DRM_FORMAT_NV24:
 214         case DRM_FORMAT_NV42:
 215                 virtual_height = height * 3;
 216                 break;
 217
 218         default:
 219                 virtual_height = height;
 220                 break;
 221         }
 222
 223         bo = bo_create_dumb(fd, width, virtual_height, bpp);
 224         if (!bo)
 225                 return NULL;
 226
 227         ret = bo_map(bo, &virtual);
 228         if (ret) {
 229                 fprintf(stderr, "failed to map buffer: %s\n",
 230                         strerror(-errno));
 231                 bo_destroy(bo);
 232                 return NULL;
 233         }
 234
 235         /* just testing a limited # of formats to test single
 236          * and multi-planar path.. would be nice to add more..
 237          */
 238         switch (format) {
 239         case DRM_FORMAT_UYVY:
 240         case DRM_FORMAT_VYUY:
 241         case DRM_FORMAT_YUYV:
 242         case DRM_FORMAT_YVYU:
 243                 offsets[0] = 0;
 244                 handles[0] = bo->handle;
 245                 pitches[0] = bo->pitch;
 246
 247                 planes[0] = virtual;
 248                 break;
 249
 250         case DRM_FORMAT_NV12:
 251         case DRM_FORMAT_NV21:
 252         case DRM_FORMAT_NV16:
 253         case DRM_FORMAT_NV61:
 254                 offsets[0] = 0;
 255                 handles[0] = bo->handle;
 256                 pitches[0] = bo->pitch;
 257                 pitches[1] = pitches[0];
 258                 offsets[1] = pitches[0] * height;
 259                 handles[1] = bo->handle;
 260
 261                 planes[0] = virtual;
 262                 planes[1] = virtual + offsets[1];
 263                 break;
 264
 265         case DRM_FORMAT_NV24:
 266         case DRM_FORMAT_NV42:
 267                 offsets[0] = 0;
 268                 handles[0] = bo->handle;
 269                 pitches[0] = bo->pitch;
 270                 pitches[1] = pitches[0] * 2;
 271                 offsets[1] = pitches[0] * height;
 272                 handles[1] = bo->handle;
 273
 274                 planes[0] = virtual;
 275                 planes[1] = virtual + offsets[1];
 276                 break;
 277
 278         case DRM_FORMAT_YUV420:
 279         case DRM_FORMAT_YVU420:
 280                 offsets[0] = 0;
 281                 handles[0] = bo->handle;
 282                 pitches[0] = bo->pitch;
 283                 pitches[1] = pitches[0] / 2;
 284                 offsets[1] = pitches[0] * height;
 285                 handles[1] = bo->handle;
 286                 pitches[2] = pitches[1];
 287                 offsets[2] = offsets[1] + pitches[1] * height / 2;
 288                 handles[2] = bo->handle;
 289
 290                 planes[0] = virtual;
 291                 planes[1] = virtual + offsets[1];
 292                 planes[2] = virtual + offsets[2];
 293                 break;
 294
 295         case DRM_FORMAT_C8:
 296         case DRM_FORMAT_ARGB4444:
 297         case DRM_FORMAT_XRGB4444:
 298         case DRM_FORMAT_ABGR4444:
 299         case DRM_FORMAT_XBGR4444:
 300         case DRM_FORMAT_RGBA4444:
 301         case DRM_FORMAT_RGBX4444:
 302         case DRM_FORMAT_BGRA4444:
 303         case DRM_FORMAT_BGRX4444:
 304         case DRM_FORMAT_ARGB1555:
 305         case DRM_FORMAT_XRGB1555:
 306         case DRM_FORMAT_ABGR1555:
 307         case DRM_FORMAT_XBGR1555:
 308         case DRM_FORMAT_RGBA5551:
 309         case DRM_FORMAT_RGBX5551:
 310         case DRM_FORMAT_BGRA5551:
 311         case DRM_FORMAT_BGRX5551:
 312         case DRM_FORMAT_RGB565:
 313         case DRM_FORMAT_BGR565:
 314         case DRM_FORMAT_BGR888:
 315         case DRM_FORMAT_RGB888:
 316         case DRM_FORMAT_ARGB8888:
 317         case DRM_FORMAT_XRGB8888:
 318         case DRM_FORMAT_ABGR8888:
 319         case DRM_FORMAT_XBGR8888:
 320         case DRM_FORMAT_RGBA8888:
 321         case DRM_FORMAT_RGBX8888:
 322         case DRM_FORMAT_BGRA8888:
 323         case DRM_FORMAT_BGRX8888:
 324         case DRM_FORMAT_ARGB2101010:
 325         case DRM_FORMAT_XRGB2101010:
 326         case DRM_FORMAT_ABGR2101010:
 327         case DRM_FORMAT_XBGR2101010:
 328         case DRM_FORMAT_RGBA1010102:
 329         case DRM_FORMAT_RGBX1010102:
 330         case DRM_FORMAT_BGRA1010102:
 331         case DRM_FORMAT_BGRX1010102:
 332         case DRM_FORMAT_XRGB16161616F:
 333         case DRM_FORMAT_XBGR16161616F:
 334         case DRM_FORMAT_ARGB16161616F:
 335         case DRM_FORMAT_ABGR16161616F:
 336                 offsets[0] = 0;
 337                 handles[0] = bo->handle;
 338                 pitches[0] = bo->pitch;
 339
 340                 planes[0] = virtual;
 341                 break;
 342         }
 343
 344         util_fill_pattern(format, pattern, planes, width, height, pitches[0]);
 345         bo_unmap(bo);
 346
 347         return bo;
 348 }
 349
 350 void bo_destroy(struct bo *bo)
 351 {
 352         int ret;
 353
 354         ret = drmModeDestroyDumbBuffer(bo->fd, bo->handle);
 355         if (ret)
 356                 fprintf(stderr, "failed to destroy dumb buffer: %s\n",
 357                         strerror(errno));
 358
 359         free(bo);
 360 }
 361
 362 void bo_dump(struct bo *bo, const char *filename)
 363 {
 364         FILE *fp;
 365
 366         if (!bo || !filename)
 367                 return;
 368
 369         fp = fopen(filename, "wb");
 370         if (fp) {
 371                 void *addr;
 372
 373                 bo_map(bo, &addr);
 374                 printf("Dumping buffer %p to file %s.\n", bo->ptr, filename);
 375                 fwrite(bo->ptr, 1, bo->size, fp);
 376                 bo_unmap(bo);
 377                 fclose(fp);
 378         }
 379 }