src/wayland-shm.c

   1 /*
   2  * Copyright © 2008 Kristian Høgsberg
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  *
  22  * Authors:
  23  *    Kristian Høgsberg <krh@bitplanet.net>
  24  *    Benjamin Franzke <benjaminfranzke@googlemail.com>
  25  *
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <sys/mman.h>
  32 #include <unistd.h>
  33
  34 #include "wayland-server.h"
  35
  36 struct wl_shm_pool {
  37         struct wl_resource resource;
  38         int refcount;
  39         char *data;
  40         int size;
  41         int fd;
  42 };
  43
  44 struct wl_shm_buffer {
  45         struct wl_buffer buffer;
  46         int32_t stride;
  47         uint32_t format;
  48         int offset;
  49         struct wl_shm_pool *pool;
  50 };
  51
  52 static void
  53 shm_pool_unref(struct wl_shm_pool *pool)
  54 {
  55         pool->refcount--;
  56         if (pool->refcount)
  57                 return;
  58
  59         munmap(pool->data, pool->size);
  60         close(pool->fd);
  61         free(pool);
  62 }
  63
  64 static void
  65 destroy_buffer(struct wl_resource *resource)
  66 {
  67         struct wl_shm_buffer *buffer =
  68                 container_of(resource, struct wl_shm_buffer, buffer.resource);
  69
  70         if (buffer->pool)
  71                 shm_pool_unref(buffer->pool);
  72         free(buffer);
  73 }
  74
  75 static void
  76 shm_buffer_destroy(struct wl_client *client, struct wl_resource *resource)
  77 {
  78         wl_resource_destroy(resource);
  79 }
  80
  81 static const struct wl_buffer_interface shm_buffer_interface = {
  82         shm_buffer_destroy
  83 };
  84
  85 static void
  86 shm_pool_create_buffer(struct wl_client *client, struct wl_resource *resource,
  87                        uint32_t id, int32_t offset,
  88                        int32_t width, int32_t height,
  89                        int32_t stride, uint32_t format)
  90 {
  91         struct wl_shm_pool *pool = resource->data;
  92         struct wl_shm_buffer *buffer;
  93
  94         switch (format) {
  95         case WL_SHM_FORMAT_ARGB8888:
  96         case WL_SHM_FORMAT_XRGB8888:
  97                 break;
  98         default:
  99                 wl_resource_post_error(resource,
 100                                        WL_SHM_ERROR_INVALID_FORMAT,
 101                                        "invalid format");
 102                 return;
 103         }
 104
 105         if (offset < 0 || width <= 0 || height <= 0 || stride < width ||
 106             INT32_MAX / stride <= height ||
 107             offset > pool->size - stride * height) {
 108                 wl_resource_post_error(resource,
 109                                        WL_SHM_ERROR_INVALID_STRIDE,
 110                                        "invalid width, height or stride (%dx%d, %u)",
 111                                        width, height, stride);
 112                 return;
 113         }
 114
 115         buffer = malloc(sizeof *buffer);
 116         if (buffer == NULL) {
 117                 wl_resource_post_no_memory(resource);
 118                 return;
 119         }
 120
 121         buffer->buffer.width = width;
 122         buffer->buffer.height = height;
 123         buffer->buffer.busy_count = 0;
 124         buffer->format = format;
 125         buffer->stride = stride;
 126         buffer->offset = offset;
 127         buffer->pool = pool;
 128         pool->refcount++;
 129
 130         buffer->buffer.resource.object.id = id;
 131         buffer->buffer.resource.object.interface = &wl_buffer_interface;
 132         buffer->buffer.resource.object.implementation = (void (**)(void))
 133                 &shm_buffer_interface;
 134
 135         buffer->buffer.resource.data = buffer;
 136         buffer->buffer.resource.client = resource->client;
 137         buffer->buffer.resource.destroy = destroy_buffer;
 138
 139         wl_client_add_resource(client, &buffer->buffer.resource);
 140 }
 141
 142 static void
 143 destroy_pool(struct wl_resource *resource)
 144 {
 145         struct wl_shm_pool *pool = resource->data;
 146
 147         shm_pool_unref(pool);
 148 }
 149
 150 static void
 151 shm_pool_destroy(struct wl_client *client, struct wl_resource *resource)
 152 {
 153         wl_resource_destroy(resource);
 154 }
 155
 156 static void
 157 shm_pool_resize(struct wl_client *client, struct wl_resource *resource,
 158                 int32_t size)
 159 {
 160         struct wl_shm_pool *pool = resource->data;
 161         void *data;
 162
 163         data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
 164                     pool->fd, 0);
 165
 166         if (data == MAP_FAILED) {
 167                 wl_resource_post_error(resource,
 168                                        WL_SHM_ERROR_INVALID_FD,
 169                                        "failed mmap fd %d", pool->fd);
 170                 return;
 171         }
 172
 173         munmap(pool->data, pool->size);
 174         pool->data = data;
 175         pool->size = size;
 176 }
 177
 178 struct wl_shm_pool_interface shm_pool_interface = {
 179         shm_pool_create_buffer,
 180         shm_pool_destroy,
 181         shm_pool_resize
 182 };
 183
 184 static void
 185 shm_create_pool(struct wl_client *client, struct wl_resource *resource,
 186                 uint32_t id, int fd, int32_t size)
 187 {
 188         struct wl_shm_pool *pool;
 189
 190         pool = malloc(sizeof *pool);
 191         if (pool == NULL) {
 192                 wl_resource_post_no_memory(resource);
 193                 close(fd);
 194                 return;
 195         }
 196
 197         if (size <= 0) {
 198                 wl_resource_post_error(resource,
 199                                        WL_SHM_ERROR_INVALID_STRIDE,
 200                                        "invalid size (%d)", size);
 201                 close(fd);
 202                 return;
 203         }
 204
 205         pool->refcount = 1;
 206         pool->fd = fd;
 207         pool->size = size;
 208         pool->data = mmap(NULL, size,
 209                           PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 210         if (pool->data == MAP_FAILED) {
 211                 wl_resource_post_error(resource,
 212                                        WL_SHM_ERROR_INVALID_FD,
 213                                        "failed mmap fd %d", fd);
 214                 return;
 215         }
 216
 217         pool->resource.object.id = id;
 218         pool->resource.object.interface = &wl_shm_pool_interface;
 219         pool->resource.object.implementation =
 220                 (void (**)(void)) &shm_pool_interface;
 221
 222         pool->resource.data = pool;
 223         pool->resource.client = client;
 224         pool->resource.destroy = destroy_pool;
 225
 226         wl_client_add_resource(client, &pool->resource);
 227 }
 228
 229 static const struct wl_shm_interface shm_interface = {
 230         shm_create_pool
 231 };
 232
 233 static void
 234 bind_shm(struct wl_client *client,
 235          void *data, uint32_t version, uint32_t id)
 236 {
 237         struct wl_resource *resource;
 238
 239         resource = wl_client_add_object(client, &wl_shm_interface,
 240                                         &shm_interface, id, data);
 241
 242         wl_shm_send_format(resource, WL_SHM_FORMAT_ARGB8888);
 243         wl_shm_send_format(resource, WL_SHM_FORMAT_XRGB8888);
 244 }
 245
 246 WL_EXPORT int
 247 wl_display_init_shm(struct wl_display *display)
 248 {
 249         if (!wl_display_add_global(display, &wl_shm_interface, NULL, bind_shm))
 250                 return -1;
 251
 252         return 0;
 253 }
 254
 255 WL_EXPORT int
 256 wl_buffer_is_shm(struct wl_buffer *buffer)
 257 {
 258         return buffer->resource.object.implementation ==
 259                 (void (**)(void)) &shm_buffer_interface;
 260 }
 261
 262 WL_EXPORT int32_t
 263 wl_shm_buffer_get_stride(struct wl_buffer *buffer_base)
 264 {
 265         struct wl_shm_buffer *buffer = (struct wl_shm_buffer *) buffer_base;
 266
 267         if (!wl_buffer_is_shm(buffer_base))
 268                 return 0;
 269
 270         return buffer->stride;
 271 }
 272
 273 WL_EXPORT void *
 274 wl_shm_buffer_get_data(struct wl_buffer *buffer_base)
 275 {
 276         struct wl_shm_buffer *buffer = (struct wl_shm_buffer *) buffer_base;
 277
 278         if (!wl_buffer_is_shm(buffer_base))
 279                 return NULL;
 280
 281         return buffer->pool->data + buffer->offset;
 282 }
 283
 284 WL_EXPORT uint32_t
 285 wl_shm_buffer_get_format(struct wl_buffer *buffer_base)
 286 {
 287         struct wl_shm_buffer *buffer = (struct wl_shm_buffer *) buffer_base;
 288
 289         return buffer->format;
 290 }