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_C1:
 128                 bpp = 1;
 129                 break;
 130
 131         case DRM_FORMAT_C2:
 132                 bpp = 2;
 133                 break;
 134
 135         case DRM_FORMAT_C4:
 136                 bpp = 4;
 137                 break;
 138
 139         case DRM_FORMAT_C8:
 140         case DRM_FORMAT_NV12:
 141         case DRM_FORMAT_NV21:
 142         case DRM_FORMAT_NV16:
 143         case DRM_FORMAT_NV61:
 144         case DRM_FORMAT_NV24:
 145         case DRM_FORMAT_NV42:
 146         case DRM_FORMAT_YUV420:
 147         case DRM_FORMAT_YVU420:
 148                 bpp = 8;
 149                 break;
 150
 151         case DRM_FORMAT_ARGB4444:
 152         case DRM_FORMAT_XRGB4444:
 153         case DRM_FORMAT_ABGR4444:
 154         case DRM_FORMAT_XBGR4444:
 155         case DRM_FORMAT_RGBA4444:
 156         case DRM_FORMAT_RGBX4444:
 157         case DRM_FORMAT_BGRA4444:
 158         case DRM_FORMAT_BGRX4444:
 159         case DRM_FORMAT_ARGB1555:
 160         case DRM_FORMAT_XRGB1555:
 161         case DRM_FORMAT_ABGR1555:
 162         case DRM_FORMAT_XBGR1555:
 163         case DRM_FORMAT_RGBA5551:
 164         case DRM_FORMAT_RGBX5551:
 165         case DRM_FORMAT_BGRA5551:
 166         case DRM_FORMAT_BGRX5551:
 167         case DRM_FORMAT_RGB565:
 168         case DRM_FORMAT_BGR565:
 169         case DRM_FORMAT_UYVY:
 170         case DRM_FORMAT_VYUY:
 171         case DRM_FORMAT_YUYV:
 172         case DRM_FORMAT_YVYU:
 173                 bpp = 16;
 174                 break;
 175
 176         case DRM_FORMAT_BGR888:
 177         case DRM_FORMAT_RGB888:
 178                 bpp = 24;
 179                 break;
 180
 181         case DRM_FORMAT_ARGB8888:
 182         case DRM_FORMAT_XRGB8888:
 183         case DRM_FORMAT_ABGR8888:
 184         case DRM_FORMAT_XBGR8888:
 185         case DRM_FORMAT_RGBA8888:
 186         case DRM_FORMAT_RGBX8888:
 187         case DRM_FORMAT_BGRA8888:
 188         case DRM_FORMAT_BGRX8888:
 189         case DRM_FORMAT_ARGB2101010:
 190         case DRM_FORMAT_XRGB2101010:
 191         case DRM_FORMAT_ABGR2101010:
 192         case DRM_FORMAT_XBGR2101010:
 193         case DRM_FORMAT_RGBA1010102:
 194         case DRM_FORMAT_RGBX1010102:
 195         case DRM_FORMAT_BGRA1010102:
 196         case DRM_FORMAT_BGRX1010102:
 197                 bpp = 32;
 198                 break;
 199
 200         case DRM_FORMAT_XRGB16161616F:
 201         case DRM_FORMAT_XBGR16161616F:
 202         case DRM_FORMAT_ARGB16161616F:
 203         case DRM_FORMAT_ABGR16161616F:
 204                 bpp = 64;
 205                 break;
 206
 207         default:
 208                 fprintf(stderr, "unsupported format 0x%08x\n",  format);
 209                 return NULL;
 210         }
 211
 212         switch (format) {
 213         case DRM_FORMAT_NV12:
 214         case DRM_FORMAT_NV21:
 215         case DRM_FORMAT_YUV420:
 216         case DRM_FORMAT_YVU420:
 217                 virtual_height = height * 3 / 2;
 218                 break;
 219
 220         case DRM_FORMAT_NV16:
 221         case DRM_FORMAT_NV61:
 222                 virtual_height = height * 2;
 223                 break;
 224
 225         case DRM_FORMAT_NV24:
 226         case DRM_FORMAT_NV42:
 227                 virtual_height = height * 3;
 228                 break;
 229
 230         default:
 231                 virtual_height = height;
 232                 break;
 233         }
 234
 235         bo = bo_create_dumb(fd, width, virtual_height, bpp);
 236         if (!bo)
 237                 return NULL;
 238
 239         ret = bo_map(bo, &virtual);
 240         if (ret) {
 241                 fprintf(stderr, "failed to map buffer: %s\n",
 242                         strerror(-errno));
 243                 bo_destroy(bo);
 244                 return NULL;
 245         }
 246
 247         /* just testing a limited # of formats to test single
 248          * and multi-planar path.. would be nice to add more..
 249          */
 250         switch (format) {
 251         case DRM_FORMAT_UYVY:
 252         case DRM_FORMAT_VYUY:
 253         case DRM_FORMAT_YUYV:
 254         case DRM_FORMAT_YVYU:
 255                 offsets[0] = 0;
 256                 handles[0] = bo->handle;
 257                 pitches[0] = bo->pitch;
 258
 259                 planes[0] = virtual;
 260                 break;
 261
 262         case DRM_FORMAT_NV12:
 263         case DRM_FORMAT_NV21:
 264         case DRM_FORMAT_NV16:
 265         case DRM_FORMAT_NV61:
 266                 offsets[0] = 0;
 267                 handles[0] = bo->handle;
 268                 pitches[0] = bo->pitch;
 269                 pitches[1] = pitches[0];
 270                 offsets[1] = pitches[0] * height;
 271                 handles[1] = bo->handle;
 272
 273                 planes[0] = virtual;
 274                 planes[1] = virtual + offsets[1];
 275                 break;
 276
 277         case DRM_FORMAT_NV24:
 278         case DRM_FORMAT_NV42:
 279                 offsets[0] = 0;
 280                 handles[0] = bo->handle;
 281                 pitches[0] = bo->pitch;
 282                 pitches[1] = pitches[0] * 2;
 283                 offsets[1] = pitches[0] * height;
 284                 handles[1] = bo->handle;
 285
 286                 planes[0] = virtual;
 287                 planes[1] = virtual + offsets[1];
 288                 break;
 289
 290         case DRM_FORMAT_YUV420:
 291         case DRM_FORMAT_YVU420:
 292                 offsets[0] = 0;
 293                 handles[0] = bo->handle;
 294                 pitches[0] = bo->pitch;
 295                 pitches[1] = pitches[0] / 2;
 296                 offsets[1] = pitches[0] * height;
 297                 handles[1] = bo->handle;
 298                 pitches[2] = pitches[1];
 299                 offsets[2] = offsets[1] + pitches[1] * height / 2;
 300                 handles[2] = bo->handle;
 301
 302                 planes[0] = virtual;
 303                 planes[1] = virtual + offsets[1];
 304                 planes[2] = virtual + offsets[2];
 305                 break;
 306
 307         case DRM_FORMAT_C1:
 308         case DRM_FORMAT_C2:
 309         case DRM_FORMAT_C4:
 310         case DRM_FORMAT_C8:
 311         case DRM_FORMAT_ARGB4444:
 312         case DRM_FORMAT_XRGB4444:
 313         case DRM_FORMAT_ABGR4444:
 314         case DRM_FORMAT_XBGR4444:
 315         case DRM_FORMAT_RGBA4444:
 316         case DRM_FORMAT_RGBX4444:
 317         case DRM_FORMAT_BGRA4444:
 318         case DRM_FORMAT_BGRX4444:
 319         case DRM_FORMAT_ARGB1555:
 320         case DRM_FORMAT_XRGB1555:
 321         case DRM_FORMAT_ABGR1555:
 322         case DRM_FORMAT_XBGR1555:
 323         case DRM_FORMAT_RGBA5551:
 324         case DRM_FORMAT_RGBX5551:
 325         case DRM_FORMAT_BGRA5551:
 326         case DRM_FORMAT_BGRX5551:
 327         case DRM_FORMAT_RGB565:
 328         case DRM_FORMAT_BGR565:
 329         case DRM_FORMAT_BGR888:
 330         case DRM_FORMAT_RGB888:
 331         case DRM_FORMAT_ARGB8888:
 332         case DRM_FORMAT_XRGB8888:
 333         case DRM_FORMAT_ABGR8888:
 334         case DRM_FORMAT_XBGR8888:
 335         case DRM_FORMAT_RGBA8888:
 336         case DRM_FORMAT_RGBX8888:
 337         case DRM_FORMAT_BGRA8888:
 338         case DRM_FORMAT_BGRX8888:
 339         case DRM_FORMAT_ARGB2101010:
 340         case DRM_FORMAT_XRGB2101010:
 341         case DRM_FORMAT_ABGR2101010:
 342         case DRM_FORMAT_XBGR2101010:
 343         case DRM_FORMAT_RGBA1010102:
 344         case DRM_FORMAT_RGBX1010102:
 345         case DRM_FORMAT_BGRA1010102:
 346         case DRM_FORMAT_BGRX1010102:
 347         case DRM_FORMAT_XRGB16161616F:
 348         case DRM_FORMAT_XBGR16161616F:
 349         case DRM_FORMAT_ARGB16161616F:
 350         case DRM_FORMAT_ABGR16161616F:
 351                 offsets[0] = 0;
 352                 handles[0] = bo->handle;
 353                 pitches[0] = bo->pitch;
 354
 355                 planes[0] = virtual;
 356                 break;
 357         }
 358
 359         util_fill_pattern(format, pattern, planes, width, height, pitches[0]);
 360         bo_unmap(bo);
 361
 362         return bo;
 363 }
 364
 365 void bo_destroy(struct bo *bo)
 366 {
 367         int ret;
 368
 369         ret = drmModeDestroyDumbBuffer(bo->fd, bo->handle);
 370         if (ret)
 371                 fprintf(stderr, "failed to destroy dumb buffer: %s\n",
 372                         strerror(errno));
 373
 374         free(bo);
 375 }
 376
 377 void bo_dump(struct bo *bo, const char *filename)
 378 {
 379         FILE *fp;
 380
 381         if (!bo || !filename)
 382                 return;
 383
 384         fp = fopen(filename, "wb");
 385         if (fp) {
 386                 void *addr;
 387
 388                 bo_map(bo, &addr);
 389                 printf("Dumping buffer %p to file %s.\n", bo->ptr, filename);
 390                 fwrite(bo->ptr, 1, bo->size, fp);
 391                 bo_unmap(bo);
 392                 fclose(fp);
 393         }
 394 }