ui/dmabuf.c

   1 /*
   2  * SPDX-License-Identifier: GPL-2.0-or-later
   3  *
   4  * QemuDmaBuf struct and helpers used for accessing its data
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "ui/dmabuf.h"
  12
  13 struct QemuDmaBuf {
  14     int       fd;
  15     uint32_t  width;
  16     uint32_t  height;
  17     uint32_t  stride;
  18     uint32_t  fourcc;
  19     uint64_t  modifier;
  20     uint32_t  texture;
  21     uint32_t  x;
  22     uint32_t  y;
  23     uint32_t  backing_width;
  24     uint32_t  backing_height;
  25     bool      y0_top;
  26     void      *sync;
  27     int       fence_fd;
  28     bool      allow_fences;
  29     bool      draw_submitted;
  30 };
  31
  32 QemuDmaBuf *qemu_dmabuf_new(uint32_t width, uint32_t height,
  33                             uint32_t stride, uint32_t x,
  34                             uint32_t y, uint32_t backing_width,
  35                             uint32_t backing_height, uint32_t fourcc,
  36                             uint64_t modifier, int32_t dmabuf_fd,
  37                             bool allow_fences, bool y0_top) {
  38     QemuDmaBuf *dmabuf;
  39
  40     dmabuf = g_new0(QemuDmaBuf, 1);
  41
  42     dmabuf->width = width;
  43     dmabuf->height = height;
  44     dmabuf->stride = stride;
  45     dmabuf->x = x;
  46     dmabuf->y = y;
  47     dmabuf->backing_width = backing_width;
  48     dmabuf->backing_height = backing_height;
  49     dmabuf->fourcc = fourcc;
  50     dmabuf->modifier = modifier;
  51     dmabuf->fd = dmabuf_fd;
  52     dmabuf->allow_fences = allow_fences;
  53     dmabuf->y0_top = y0_top;
  54     dmabuf->fence_fd = -1;
  55
  56     return dmabuf;
  57 }
  58
  59 void qemu_dmabuf_free(QemuDmaBuf *dmabuf)
  60 {
  61     if (dmabuf == NULL) {
  62         return;
  63     }
  64
  65     g_free(dmabuf);
  66 }
  67
  68 int qemu_dmabuf_get_fd(QemuDmaBuf *dmabuf)
  69 {
  70     assert(dmabuf != NULL);
  71
  72     return dmabuf->fd;
  73 }
  74
  75 int qemu_dmabuf_dup_fd(QemuDmaBuf *dmabuf)
  76 {
  77     assert(dmabuf != NULL);
  78
  79     if (dmabuf->fd >= 0) {
  80         return dup(dmabuf->fd);
  81     } else {
  82         return -1;
  83     }
  84 }
  85
  86 void qemu_dmabuf_close(QemuDmaBuf *dmabuf)
  87 {
  88     assert(dmabuf != NULL);
  89
  90     if (dmabuf->fd >= 0) {
  91         close(dmabuf->fd);
  92         dmabuf->fd = -1;
  93     }
  94 }
  95
  96 uint32_t qemu_dmabuf_get_width(QemuDmaBuf *dmabuf)
  97 {
  98     assert(dmabuf != NULL);
  99
 100     return dmabuf->width;
 101 }
 102
 103 uint32_t qemu_dmabuf_get_height(QemuDmaBuf *dmabuf)
 104 {
 105     assert(dmabuf != NULL);
 106
 107     return dmabuf->height;
 108 }
 109
 110 uint32_t qemu_dmabuf_get_stride(QemuDmaBuf *dmabuf)
 111 {
 112     assert(dmabuf != NULL);
 113
 114     return dmabuf->stride;
 115 }
 116
 117 uint32_t qemu_dmabuf_get_fourcc(QemuDmaBuf *dmabuf)
 118 {
 119     assert(dmabuf != NULL);
 120
 121     return dmabuf->fourcc;
 122 }
 123
 124 uint64_t qemu_dmabuf_get_modifier(QemuDmaBuf *dmabuf)
 125 {
 126     assert(dmabuf != NULL);
 127
 128     return dmabuf->modifier;
 129 }
 130
 131 uint32_t qemu_dmabuf_get_texture(QemuDmaBuf *dmabuf)
 132 {
 133     assert(dmabuf != NULL);
 134
 135     return dmabuf->texture;
 136 }
 137
 138 uint32_t qemu_dmabuf_get_x(QemuDmaBuf *dmabuf)
 139 {
 140     assert(dmabuf != NULL);
 141
 142     return dmabuf->x;
 143 }
 144
 145 uint32_t qemu_dmabuf_get_y(QemuDmaBuf *dmabuf)
 146 {
 147     assert(dmabuf != NULL);
 148
 149     return dmabuf->y;
 150 }
 151
 152 uint32_t qemu_dmabuf_get_backing_width(QemuDmaBuf *dmabuf)
 153 {
 154     assert(dmabuf != NULL);
 155
 156     return dmabuf->backing_width;
 157 }
 158
 159 uint32_t qemu_dmabuf_get_backing_height(QemuDmaBuf *dmabuf)
 160 {
 161     assert(dmabuf != NULL);
 162
 163     return dmabuf->backing_height;
 164 }
 165
 166 bool qemu_dmabuf_get_y0_top(QemuDmaBuf *dmabuf)
 167 {
 168     assert(dmabuf != NULL);
 169
 170     return dmabuf->y0_top;
 171 }
 172
 173 void *qemu_dmabuf_get_sync(QemuDmaBuf *dmabuf)
 174 {
 175     assert(dmabuf != NULL);
 176
 177     return dmabuf->sync;
 178 }
 179
 180 int32_t qemu_dmabuf_get_fence_fd(QemuDmaBuf *dmabuf)
 181 {
 182     assert(dmabuf != NULL);
 183
 184     return dmabuf->fence_fd;
 185 }
 186
 187 bool qemu_dmabuf_get_allow_fences(QemuDmaBuf *dmabuf)
 188 {
 189     assert(dmabuf != NULL);
 190
 191     return dmabuf->allow_fences;
 192 }
 193
 194 bool qemu_dmabuf_get_draw_submitted(QemuDmaBuf *dmabuf)
 195 {
 196     assert(dmabuf != NULL);
 197
 198     return dmabuf->draw_submitted;
 199 }
 200
 201 void qemu_dmabuf_set_texture(QemuDmaBuf *dmabuf, uint32_t texture)
 202 {
 203     assert(dmabuf != NULL);
 204     dmabuf->texture = texture;
 205 }
 206
 207 void qemu_dmabuf_set_fence_fd(QemuDmaBuf *dmabuf, int32_t fence_fd)
 208 {
 209     assert(dmabuf != NULL);
 210     dmabuf->fence_fd = fence_fd;
 211 }
 212
 213 void qemu_dmabuf_set_sync(QemuDmaBuf *dmabuf, void *sync)
 214 {
 215     assert(dmabuf != NULL);
 216     dmabuf->sync = sync;
 217 }
 218
 219 void qemu_dmabuf_set_draw_submitted(QemuDmaBuf *dmabuf, bool draw_submitted)
 220 {
 221     assert(dmabuf != NULL);
 222     dmabuf->draw_submitted = draw_submitted;
 223 }
 224
 225 void qemu_dmabuf_set_fd(QemuDmaBuf *dmabuf, int32_t fd)
 226 {
 227     assert(dmabuf != NULL);
 228     dmabuf->fd = fd;
 229 }