gfx-examples/wl-tester/buffers.c

/*
 * Source updates from:
 * - https://wayland-book.com/xdg-shell-basics/example-code.html
 * - libdrm's "modetest"
 */

 /*
 * DRM based mode setting test program
 * Copyright 2008 Tungsten Graphics
 *   Jakob Bornecrantz <jakob@tungstengraphics.com>
 * Copyright 2008 Intel Corporation
 *   Jesse Barnes <jesse.barnes@intel.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <time.h>
#include <unistd.h>

#include "drm/drm.h"
#include "drm/drm_fourcc.h"
#include "xf86drm.h"

#include "buffers.h"

long int raw_offset = 0;

static void randname(char *buf) {
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME, &ts);
  long r = ts.tv_nsec;
  for (int i = 0; i < 6; ++i) {
    buf[i] = 'A' + (r & 15) + (r & 16) * 2;
    r >>= 5;
  }
}

static int create_shm_file(void) {
  int retries = 100;
  do {
    char name[] = "/wl_shm-XXXXXX";
    randname(name + sizeof(name) - 7);
    --retries;
    int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
    if (fd >= 0) {
      shm_unlink(name);
      return fd;
    }
  } while (retries > 0 && errno == EEXIST);
  return -1;
}

int allocate_shm_file(size_t size) {
  int fd = create_shm_file();
  if (fd < 0)
    return -1;
  int ret;
  do {
    ret = ftruncate(fd, size);
  } while (ret < 0 && errno == EINTR);
  if (ret < 0) {
    close(fd);
    return -1;
  }
  return fd;
}

int fill_with_raw(FILE *fp, uint32_t width, uint32_t height,
                 uint8_t *data) {
  fseek(fp, 0, SEEK_END);
  uint32_t file_size = ftell(fp);
  uint32_t frame_size = (width * height + 2 * ((width + 1) / 2) * ((height + 1) / 2));
  fseek(fp, raw_offset, SEEK_SET);

  size_t result = fread(data, 1, frame_size, fp);
  if (result != frame_size) {
    fprintf(stderr, "Error reading yuv image\n");
    return -1;
  }

  raw_offset = raw_offset + frame_size;
  if (raw_offset >= file_size)
    raw_offset = 0;
  return 0;
}

struct bo *bo_create_dumb(int fd, unsigned int width,
                                 unsigned int height, unsigned int bpp) {
  struct drm_mode_create_dumb arg;
  struct bo *bo;
  int ret;

  bo = calloc(1, sizeof(*bo));
  if (bo == NULL) {
    fprintf(stderr, "failed to allocate buffer object\n");
    return NULL;
  }

  memset(&arg, 0, sizeof(arg));
  arg.bpp = bpp;
  arg.width = width;
  arg.height = height;

  ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &arg);
  if (ret) {
    fprintf(stderr, "failed to create dumb buffer: %s\n", strerror(errno));
    free(bo);
    return NULL;
  }

  bo->fd = fd;
  bo->handle = arg.handle;
  bo->size = arg.size;
  bo->pitch = arg.pitch;

  return bo;
}

int bo_map(struct bo *bo, void **out) {
  struct drm_mode_map_dumb arg;
  void *map;
  int ret;

  memset(&arg, 0, sizeof(arg));
  arg.handle = bo->handle;

  ret = drmIoctl(bo->fd, DRM_IOCTL_MODE_MAP_DUMB, &arg);
  if (ret)
    return ret;

  map =
      mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED, bo->fd, arg.offset);

  bo->ptr = map;
  *out = map;

  return 0;
}

void bo_unmap(struct bo *bo) {
  if (!bo->ptr)
    return;

  munmap(bo->ptr, bo->size);
  bo->ptr = NULL;
}

struct bo *bo_create(int fd, unsigned int format, unsigned int width,
                     unsigned int height, unsigned int handles[4],
                     unsigned int pitches[4], unsigned int offsets[4]) {
  unsigned int virtual_height;
  struct bo *bo;
  unsigned int bpp;
  void *planes[3] = {
      0,
  };
  void *virtual;
  int ret;

  switch (format) {
  case DRM_FORMAT_C8:
  case DRM_FORMAT_NV12:
  case DRM_FORMAT_NV21:
  case DRM_FORMAT_NV16:
  case DRM_FORMAT_NV61:
  case DRM_FORMAT_YUV420:
  case DRM_FORMAT_YVU420:
    bpp = 8;
    break;

  case DRM_FORMAT_ARGB4444:
  case DRM_FORMAT_XRGB4444:
  case DRM_FORMAT_ABGR4444:
  case DRM_FORMAT_XBGR4444:
  case DRM_FORMAT_RGBA4444:
  case DRM_FORMAT_RGBX4444:
  case DRM_FORMAT_BGRA4444:
  case DRM_FORMAT_BGRX4444:
  case DRM_FORMAT_ARGB1555:
  case DRM_FORMAT_XRGB1555:
  case DRM_FORMAT_ABGR1555:
  case DRM_FORMAT_XBGR1555:
  case DRM_FORMAT_RGBA5551:
  case DRM_FORMAT_RGBX5551:
  case DRM_FORMAT_BGRA5551:
  case DRM_FORMAT_BGRX5551:
  case DRM_FORMAT_RGB565:
  case DRM_FORMAT_BGR565:
  case DRM_FORMAT_UYVY:
  case DRM_FORMAT_VYUY:
  case DRM_FORMAT_YUYV:
  case DRM_FORMAT_YVYU:
    bpp = 16;
    break;

  case DRM_FORMAT_BGR888:
  case DRM_FORMAT_RGB888:
    bpp = 24;
    break;

  case DRM_FORMAT_ARGB8888:
  case DRM_FORMAT_XRGB8888:
  case DRM_FORMAT_ABGR8888:
  case DRM_FORMAT_XBGR8888:
  case DRM_FORMAT_RGBA8888:
  case DRM_FORMAT_RGBX8888:
  case DRM_FORMAT_BGRA8888:
  case DRM_FORMAT_BGRX8888:
  case DRM_FORMAT_ARGB2101010:
  case DRM_FORMAT_XRGB2101010:
  case DRM_FORMAT_ABGR2101010:
  case DRM_FORMAT_XBGR2101010:
  case DRM_FORMAT_RGBA1010102:
  case DRM_FORMAT_RGBX1010102:
  case DRM_FORMAT_BGRA1010102:
  case DRM_FORMAT_BGRX1010102:
    bpp = 32;
    break;

  case DRM_FORMAT_XRGB16161616F:
  case DRM_FORMAT_XBGR16161616F:
  case DRM_FORMAT_ARGB16161616F:
  case DRM_FORMAT_ABGR16161616F:
    bpp = 64;
    break;

  default:
    fprintf(stderr, "unsupported format 0x%08x\n", format);
    return NULL;
  }

  switch (format) {
  case DRM_FORMAT_NV12:
  case DRM_FORMAT_NV21:
  case DRM_FORMAT_YUV420:
  case DRM_FORMAT_YVU420:
    virtual_height = height * 3 / 2;
    break;

  case DRM_FORMAT_NV16:
  case DRM_FORMAT_NV61:
    virtual_height = height * 2;
    break;

  default:
    virtual_height = height;
    break;
  }

  bo = bo_create_dumb(fd, width, virtual_height, bpp);
  if (!bo)
    return NULL;

  ret = bo_map(bo, &virtual);
  if (ret) {
    fprintf(stderr, "failed to map buffer: %s\n", strerror(-errno));
    bo_destroy(bo);
    return NULL;
  }

  /* just testing a limited # of formats to test single
   * and multi-planar path.. would be nice to add more..
   */
  switch (format) {
  case DRM_FORMAT_UYVY:
  case DRM_FORMAT_VYUY:
  case DRM_FORMAT_YUYV:
  case DRM_FORMAT_YVYU:
    offsets[0] = 0;
    handles[0] = bo->handle;
    pitches[0] = bo->pitch;

    planes[0] = virtual;
    break;

  case DRM_FORMAT_NV12:
  case DRM_FORMAT_NV21:
  case DRM_FORMAT_NV16:
  case DRM_FORMAT_NV61:
    offsets[0] = 0;
    handles[0] = bo->handle;
    pitches[0] = bo->pitch;
    pitches[1] = pitches[0];
    offsets[1] = pitches[0] * height;
    handles[1] = bo->handle;

    planes[0] = virtual;
    planes[1] = virtual + offsets[1];
    break;

  case DRM_FORMAT_YUV420:
  case DRM_FORMAT_YVU420:
    offsets[0] = 0;
    handles[0] = bo->handle;
    pitches[0] = bo->pitch;
    pitches[1] = pitches[0] / 2;
    offsets[1] = pitches[0] * height;
    handles[1] = bo->handle;
    pitches[2] = pitches[1];
    offsets[2] = offsets[1] + pitches[1] * height / 2;
    handles[2] = bo->handle;

    planes[0] = virtual;
    planes[1] = virtual + offsets[1];
    planes[2] = virtual + offsets[2];
    break;

  case DRM_FORMAT_C8:
  case DRM_FORMAT_ARGB4444:
  case DRM_FORMAT_XRGB4444:
  case DRM_FORMAT_ABGR4444:
  case DRM_FORMAT_XBGR4444:
  case DRM_FORMAT_RGBA4444:
  case DRM_FORMAT_RGBX4444:
  case DRM_FORMAT_BGRA4444:
  case DRM_FORMAT_BGRX4444:
  case DRM_FORMAT_ARGB1555:
  case DRM_FORMAT_XRGB1555:
  case DRM_FORMAT_ABGR1555:
  case DRM_FORMAT_XBGR1555:
  case DRM_FORMAT_RGBA5551:
  case DRM_FORMAT_RGBX5551:
  case DRM_FORMAT_BGRA5551:
  case DRM_FORMAT_BGRX5551:
  case DRM_FORMAT_RGB565:
  case DRM_FORMAT_BGR565:
  case DRM_FORMAT_BGR888:
  case DRM_FORMAT_RGB888:
  case DRM_FORMAT_ARGB8888:
  case DRM_FORMAT_XRGB8888:
  case DRM_FORMAT_ABGR8888:
  case DRM_FORMAT_XBGR8888:
  case DRM_FORMAT_RGBA8888:
  case DRM_FORMAT_RGBX8888:
  case DRM_FORMAT_BGRA8888:
  case DRM_FORMAT_BGRX8888:
  case DRM_FORMAT_ARGB2101010:
  case DRM_FORMAT_XRGB2101010:
  case DRM_FORMAT_ABGR2101010:
  case DRM_FORMAT_XBGR2101010:
  case DRM_FORMAT_RGBA1010102:
  case DRM_FORMAT_RGBX1010102:
  case DRM_FORMAT_BGRA1010102:
  case DRM_FORMAT_BGRX1010102:
  case DRM_FORMAT_XRGB16161616F:
  case DRM_FORMAT_XBGR16161616F:
  case DRM_FORMAT_ARGB16161616F:
  case DRM_FORMAT_ABGR16161616F:
    offsets[0] = 0;
    handles[0] = bo->handle;
    pitches[0] = bo->pitch;

    planes[0] = virtual;
    break;
  }

  bo_unmap(bo);

  return bo;
}

void bo_destroy(struct bo *bo) {
  struct drm_mode_destroy_dumb arg;
  int ret;

  memset(&arg, 0, sizeof(arg));
  arg.handle = bo->handle;

  ret = drmIoctl(bo->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &arg);
  if (ret)
    fprintf(stderr, "failed to destroy dumb buffer: %s\n", strerror(errno));

  free(bo);
}