blob: 67850b0bdb72985494d404396b7fe3967d5dd0de [file] [log] [blame]
George Kiagiadakis53868982014-06-12 16:26:49 +02001/*
2 * Copyright © 2011 Benjamin Franzke
3 * Copyright © 2010 Intel Corporation
4 * Copyright © 2014 Collabora Ltd.
5 *
Yong Bakos53361532017-01-23 06:17:44 -08006 * Permission is hereby granted, free of charge, to any person obtaining
7 * a copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sublicense, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
George Kiagiadakis53868982014-06-12 16:26:49 +020013 *
Yong Bakos53361532017-01-23 06:17:44 -080014 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial
16 * portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
22 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
23 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
George Kiagiadakis53868982014-06-12 16:26:49 +020026 */
27
Bryce Harringtonb4dae9b2016-06-15 18:13:07 -070028#include "config.h"
George Kiagiadakis53868982014-06-12 16:26:49 +020029
Jussi Kukkonen649bbce2016-07-19 14:16:27 +030030#include <stdint.h>
George Kiagiadakis53868982014-06-12 16:26:49 +020031#include <stdio.h>
32#include <stdlib.h>
33#include <string.h>
34#include <stdbool.h>
35#include <assert.h>
36#include <unistd.h>
37#include <sys/mman.h>
38#include <signal.h>
39#include <fcntl.h>
40
41#include <xf86drm.h>
Emmanuel Gil Peyrot8ef29572016-01-11 19:04:37 +000042#include <i915_drm.h>
43#include <intel_bufmgr.h>
44#include <drm_fourcc.h>
George Kiagiadakis53868982014-06-12 16:26:49 +020045
46#include <wayland-client.h>
Bryce Harrington0d1a6222016-02-11 16:42:49 -080047#include "shared/zalloc.h"
Jonas Ådahl42682622016-08-11 23:44:41 +080048#include "xdg-shell-unstable-v6-client-protocol.h"
Jonas Ådahl496adb32015-11-17 16:00:27 +080049#include "fullscreen-shell-unstable-v1-client-protocol.h"
Jonas Ådahl57e48f02015-11-17 16:00:28 +080050#include "linux-dmabuf-unstable-v1-client-protocol.h"
George Kiagiadakis53868982014-06-12 16:26:49 +020051
52struct display {
53 struct wl_display *display;
54 struct wl_registry *registry;
55 struct wl_compositor *compositor;
Jonas Ådahl42682622016-08-11 23:44:41 +080056 struct zxdg_shell_v6 *shell;
Jonas Ådahl496adb32015-11-17 16:00:27 +080057 struct zwp_fullscreen_shell_v1 *fshell;
Jonas Ådahl57e48f02015-11-17 16:00:28 +080058 struct zwp_linux_dmabuf_v1 *dmabuf;
George Kiagiadakis53868982014-06-12 16:26:49 +020059 int xrgb8888_format_found;
60};
61
62struct buffer {
63 struct wl_buffer *buffer;
64 int busy;
65
66 int drm_fd;
67
68 drm_intel_bufmgr *bufmgr;
69 drm_intel_bo *bo;
70
71 uint32_t gem_handle;
72 int dmabuf_fd;
73 uint8_t *mmap;
74
75 int width;
76 int height;
77 int bpp;
78 unsigned long stride;
79};
80
Pekka Paalanend56b94a2016-06-10 13:13:01 +030081#define NUM_BUFFERS 3
82
George Kiagiadakis53868982014-06-12 16:26:49 +020083struct window {
84 struct display *display;
85 int width, height;
86 struct wl_surface *surface;
Jonas Ådahl42682622016-08-11 23:44:41 +080087 struct zxdg_surface_v6 *xdg_surface;
88 struct zxdg_toplevel_v6 *xdg_toplevel;
Pekka Paalanend56b94a2016-06-10 13:13:01 +030089 struct buffer buffers[NUM_BUFFERS];
George Kiagiadakis53868982014-06-12 16:26:49 +020090 struct buffer *prev_buffer;
91 struct wl_callback *callback;
Jonas Ådahl42682622016-08-11 23:44:41 +080092 bool initialized;
93 bool wait_for_configure;
George Kiagiadakis53868982014-06-12 16:26:49 +020094};
95
96static int running = 1;
97
98static void
Jonas Ådahl42682622016-08-11 23:44:41 +080099redraw(void *data, struct wl_callback *callback, uint32_t time);
100
101static void
George Kiagiadakis53868982014-06-12 16:26:49 +0200102buffer_release(void *data, struct wl_buffer *buffer)
103{
104 struct buffer *mybuf = data;
105
106 mybuf->busy = 0;
107}
108
109static const struct wl_buffer_listener buffer_listener = {
110 buffer_release
111};
112
113static int
114drm_connect(struct buffer *my_buf)
115{
116 /* This won't work with card0 as we need to be authenticated; instead,
117 * boot with drm.rnodes=1 and use that. */
118 my_buf->drm_fd = open("/dev/dri/renderD128", O_RDWR);
119 if (my_buf->drm_fd < 0)
120 return 0;
121
122 my_buf->bufmgr = drm_intel_bufmgr_gem_init(my_buf->drm_fd, 32);
123 if (!my_buf->bufmgr)
124 return 0;
125
126 return 1;
127}
128
129static void
130drm_shutdown(struct buffer *my_buf)
131{
132 drm_intel_bufmgr_destroy(my_buf->bufmgr);
133 close(my_buf->drm_fd);
134}
135
136static int
137alloc_bo(struct buffer *my_buf)
138{
139 /* XXX: try different tiling modes for testing FB modifiers. */
140 uint32_t tiling = I915_TILING_NONE;
141
142 assert(my_buf->bufmgr);
143
144 my_buf->bo = drm_intel_bo_alloc_tiled(my_buf->bufmgr, "test",
145 my_buf->width, my_buf->height,
146 (my_buf->bpp / 8), &tiling,
147 &my_buf->stride, 0);
148
149 printf("buffer allocated w %d, h %d, stride %lu, size %lu\n",
150 my_buf->width, my_buf->height, my_buf->stride, my_buf->bo->size);
151
152 if (!my_buf->bo)
153 return 0;
154
155 if (tiling != I915_TILING_NONE)
156 return 0;
157
158 return 1;
159}
160
161static void
162free_bo(struct buffer *my_buf)
163{
164 drm_intel_bo_unreference(my_buf->bo);
165}
166
167static int
168map_bo(struct buffer *my_buf)
169{
170 if (drm_intel_gem_bo_map_gtt(my_buf->bo) != 0)
171 return 0;
172
173 my_buf->mmap = my_buf->bo->virtual;
174
175 return 1;
176}
177
178static void
179fill_content(struct buffer *my_buf)
180{
181 int x = 0, y = 0;
182 uint32_t *pix;
183
184 assert(my_buf->mmap);
185
186 for (y = 0; y < my_buf->height; y++) {
187 pix = (uint32_t *)(my_buf->mmap + y * my_buf->stride);
188 for (x = 0; x < my_buf->width; x++) {
189 *pix++ = (0xff << 24) | ((x % 256) << 16) |
190 ((y % 256) << 8) | 0xf0;
191 }
192 }
193}
194
195static void
196unmap_bo(struct buffer *my_buf)
197{
198 drm_intel_gem_bo_unmap_gtt(my_buf->bo);
199}
200
201static void
202create_succeeded(void *data,
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800203 struct zwp_linux_buffer_params_v1 *params,
George Kiagiadakis53868982014-06-12 16:26:49 +0200204 struct wl_buffer *new_buffer)
205{
206 struct buffer *buffer = data;
207
208 buffer->buffer = new_buffer;
209 wl_buffer_add_listener(buffer->buffer, &buffer_listener, buffer);
210
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800211 zwp_linux_buffer_params_v1_destroy(params);
George Kiagiadakis53868982014-06-12 16:26:49 +0200212}
213
214static void
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800215create_failed(void *data, struct zwp_linux_buffer_params_v1 *params)
George Kiagiadakis53868982014-06-12 16:26:49 +0200216{
217 struct buffer *buffer = data;
218
219 buffer->buffer = NULL;
Emmanuel Gil Peyrot8ef29572016-01-11 19:04:37 +0000220 running = 0;
George Kiagiadakis53868982014-06-12 16:26:49 +0200221
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800222 zwp_linux_buffer_params_v1_destroy(params);
George Kiagiadakis53868982014-06-12 16:26:49 +0200223
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800224 fprintf(stderr, "Error: zwp_linux_buffer_params.create failed.\n");
George Kiagiadakis53868982014-06-12 16:26:49 +0200225}
226
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800227static const struct zwp_linux_buffer_params_v1_listener params_listener = {
George Kiagiadakis53868982014-06-12 16:26:49 +0200228 create_succeeded,
229 create_failed
230};
231
232static int
233create_dmabuf_buffer(struct display *display, struct buffer *buffer,
234 int width, int height)
235{
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800236 struct zwp_linux_buffer_params_v1 *params;
George Kiagiadakis53868982014-06-12 16:26:49 +0200237 uint64_t modifier;
238 uint32_t flags;
239
240 if (!drm_connect(buffer)) {
241 fprintf(stderr, "drm_connect failed\n");
242 goto error;
243 }
244
245 buffer->width = width;
246 buffer->height = height;
247 buffer->bpp = 32; /* hardcoded XRGB8888 format */
248
249 if (!alloc_bo(buffer)) {
250 fprintf(stderr, "alloc_bo failed\n");
251 goto error1;
252 }
253
254 if (!map_bo(buffer)) {
255 fprintf(stderr, "map_bo failed\n");
256 goto error2;
257 }
258 fill_content(buffer);
259 unmap_bo(buffer);
260
261 if (drm_intel_bo_gem_export_to_prime(buffer->bo, &buffer->dmabuf_fd) != 0) {
262 fprintf(stderr, "drm_intel_bo_gem_export_to_prime failed\n");
263 goto error2;
264 }
265 if (buffer->dmabuf_fd < 0) {
266 fprintf(stderr, "error: dmabuf_fd < 0\n");
267 goto error2;
268 }
269
270 /* We now have a dmabuf! It should contain 2x2 tiles (i.e. each tile
271 * is 256x256) of misc colours, and be mappable, either as ARGB8888, or
272 * XRGB8888. */
273 modifier = 0;
274 flags = 0;
275
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800276 params = zwp_linux_dmabuf_v1_create_params(display->dmabuf);
277 zwp_linux_buffer_params_v1_add(params,
278 buffer->dmabuf_fd,
279 0, /* plane_idx */
280 0, /* offset */
281 buffer->stride,
282 modifier >> 32,
283 modifier & 0xffffffff);
284 zwp_linux_buffer_params_v1_add_listener(params, &params_listener, buffer);
285 zwp_linux_buffer_params_v1_create(params,
286 buffer->width,
287 buffer->height,
288 DRM_FORMAT_XRGB8888,
289 flags);
George Kiagiadakis53868982014-06-12 16:26:49 +0200290
George Kiagiadakis53868982014-06-12 16:26:49 +0200291 return 0;
292
293error2:
294 free_bo(buffer);
295error1:
296 drm_shutdown(buffer);
297error:
298 return -1;
299}
300
301static void
Jonas Ådahl42682622016-08-11 23:44:41 +0800302xdg_surface_handle_configure(void *data, struct zxdg_surface_v6 *surface,
303 uint32_t serial)
304{
305 struct window *window = data;
306
307 zxdg_surface_v6_ack_configure(surface, serial);
308
309 if (window->initialized && window->wait_for_configure)
310 redraw(window, NULL, 0);
311 window->wait_for_configure = false;
312}
313
314static const struct zxdg_surface_v6_listener xdg_surface_listener = {
315 xdg_surface_handle_configure,
316};
317
318static void
319xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *toplevel,
320 int32_t width, int32_t height,
321 struct wl_array *states)
George Kiagiadakis53868982014-06-12 16:26:49 +0200322{
323}
324
325static void
Jonas Ådahl42682622016-08-11 23:44:41 +0800326xdg_toplevel_handle_close(void *data, struct zxdg_toplevel_v6 *xdg_toplevel)
George Kiagiadakis53868982014-06-12 16:26:49 +0200327{
328 running = 0;
329}
330
Jonas Ådahl42682622016-08-11 23:44:41 +0800331static const struct zxdg_toplevel_v6_listener xdg_toplevel_listener = {
332 xdg_toplevel_handle_configure,
333 xdg_toplevel_handle_close,
George Kiagiadakis53868982014-06-12 16:26:49 +0200334};
335
336static struct window *
337create_window(struct display *display, int width, int height)
338{
339 struct window *window;
Emmanuel Gil Peyrot8ef29572016-01-11 19:04:37 +0000340 int i;
341 int ret;
George Kiagiadakis53868982014-06-12 16:26:49 +0200342
Bryce Harrington0d1a6222016-02-11 16:42:49 -0800343 window = zalloc(sizeof *window);
George Kiagiadakis53868982014-06-12 16:26:49 +0200344 if (!window)
345 return NULL;
346
347 window->callback = NULL;
348 window->display = display;
349 window->width = width;
350 window->height = height;
351 window->surface = wl_compositor_create_surface(display->compositor);
352
353 if (display->shell) {
354 window->xdg_surface =
Jonas Ådahl42682622016-08-11 23:44:41 +0800355 zxdg_shell_v6_get_xdg_surface(display->shell,
356 window->surface);
George Kiagiadakis53868982014-06-12 16:26:49 +0200357
358 assert(window->xdg_surface);
359
Jonas Ådahl42682622016-08-11 23:44:41 +0800360 zxdg_surface_v6_add_listener(window->xdg_surface,
361 &xdg_surface_listener, window);
George Kiagiadakis53868982014-06-12 16:26:49 +0200362
Jonas Ådahl42682622016-08-11 23:44:41 +0800363 window->xdg_toplevel =
364 zxdg_surface_v6_get_toplevel(window->xdg_surface);
365
366 assert(window->xdg_toplevel);
367
368 zxdg_toplevel_v6_add_listener(window->xdg_toplevel,
369 &xdg_toplevel_listener, window);
370
371 zxdg_toplevel_v6_set_title(window->xdg_toplevel, "simple-dmabuf");
372
373 window->wait_for_configure = true;
374 wl_surface_commit(window->surface);
George Kiagiadakis53868982014-06-12 16:26:49 +0200375 } else if (display->fshell) {
Jonas Ådahl496adb32015-11-17 16:00:27 +0800376 zwp_fullscreen_shell_v1_present_surface(display->fshell,
377 window->surface,
378 ZWP_FULLSCREEN_SHELL_V1_PRESENT_METHOD_DEFAULT,
379 NULL);
George Kiagiadakis53868982014-06-12 16:26:49 +0200380 } else {
381 assert(0);
382 }
383
Pekka Paalanend56b94a2016-06-10 13:13:01 +0300384 for (i = 0; i < NUM_BUFFERS; ++i) {
Emmanuel Gil Peyrot8ef29572016-01-11 19:04:37 +0000385 ret = create_dmabuf_buffer(display, &window->buffers[i],
386 width, height);
387
388 if (ret < 0)
389 return NULL;
390 }
391
George Kiagiadakis53868982014-06-12 16:26:49 +0200392 return window;
393}
394
395static void
396destroy_window(struct window *window)
397{
398 int i;
399
400 if (window->callback)
401 wl_callback_destroy(window->callback);
402
Pekka Paalanend56b94a2016-06-10 13:13:01 +0300403 for (i = 0; i < NUM_BUFFERS; i++) {
George Kiagiadakis53868982014-06-12 16:26:49 +0200404 if (!window->buffers[i].buffer)
405 continue;
406
407 wl_buffer_destroy(window->buffers[i].buffer);
408 free_bo(&window->buffers[i]);
409 close(window->buffers[i].dmabuf_fd);
410 drm_shutdown(&window->buffers[i]);
411 }
412
Jonas Ådahl42682622016-08-11 23:44:41 +0800413 if (window->xdg_toplevel)
414 zxdg_toplevel_v6_destroy(window->xdg_toplevel);
George Kiagiadakis53868982014-06-12 16:26:49 +0200415 if (window->xdg_surface)
Jonas Ådahl42682622016-08-11 23:44:41 +0800416 zxdg_surface_v6_destroy(window->xdg_surface);
George Kiagiadakis53868982014-06-12 16:26:49 +0200417 wl_surface_destroy(window->surface);
418 free(window);
419}
420
421static struct buffer *
422window_next_buffer(struct window *window)
423{
Pekka Paalanend56b94a2016-06-10 13:13:01 +0300424 int i;
George Kiagiadakis53868982014-06-12 16:26:49 +0200425
Pekka Paalanend56b94a2016-06-10 13:13:01 +0300426 for (i = 0; i < NUM_BUFFERS; i++)
427 if (!window->buffers[i].busy)
428 return &window->buffers[i];
George Kiagiadakis53868982014-06-12 16:26:49 +0200429
Pekka Paalanend56b94a2016-06-10 13:13:01 +0300430 return NULL;
George Kiagiadakis53868982014-06-12 16:26:49 +0200431}
432
433static const struct wl_callback_listener frame_listener;
434
435static void
436redraw(void *data, struct wl_callback *callback, uint32_t time)
437{
438 struct window *window = data;
439 struct buffer *buffer;
440
441 buffer = window_next_buffer(window);
442 if (!buffer) {
443 fprintf(stderr,
444 !callback ? "Failed to create the first buffer.\n" :
Pekka Paalanend56b94a2016-06-10 13:13:01 +0300445 "All buffers busy at redraw(). Server bug?\n");
George Kiagiadakis53868982014-06-12 16:26:49 +0200446 abort();
447 }
448
449 /* XXX: would be nice to draw something that changes here... */
450
451 wl_surface_attach(window->surface, buffer->buffer, 0, 0);
452 wl_surface_damage(window->surface, 0, 0, window->width, window->height);
453
454 if (callback)
455 wl_callback_destroy(callback);
456
457 window->callback = wl_surface_frame(window->surface);
458 wl_callback_add_listener(window->callback, &frame_listener, window);
459 wl_surface_commit(window->surface);
460 buffer->busy = 1;
461}
462
463static const struct wl_callback_listener frame_listener = {
464 redraw
465};
466
467static void
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800468dmabuf_format(void *data, struct zwp_linux_dmabuf_v1 *zwp_linux_dmabuf, uint32_t format)
George Kiagiadakis53868982014-06-12 16:26:49 +0200469{
470 struct display *d = data;
471
472 if (format == DRM_FORMAT_XRGB8888)
473 d->xrgb8888_format_found = 1;
474}
475
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800476static const struct zwp_linux_dmabuf_v1_listener dmabuf_listener = {
George Kiagiadakis53868982014-06-12 16:26:49 +0200477 dmabuf_format
478};
479
480static void
Jonas Ådahl42682622016-08-11 23:44:41 +0800481xdg_shell_ping(void *data, struct zxdg_shell_v6 *shell, uint32_t serial)
George Kiagiadakis53868982014-06-12 16:26:49 +0200482{
Jonas Ådahl42682622016-08-11 23:44:41 +0800483 zxdg_shell_v6_pong(shell, serial);
George Kiagiadakis53868982014-06-12 16:26:49 +0200484}
485
Jonas Ådahl42682622016-08-11 23:44:41 +0800486static const struct zxdg_shell_v6_listener xdg_shell_listener = {
George Kiagiadakis53868982014-06-12 16:26:49 +0200487 xdg_shell_ping,
488};
489
George Kiagiadakis53868982014-06-12 16:26:49 +0200490static void
491registry_handle_global(void *data, struct wl_registry *registry,
492 uint32_t id, const char *interface, uint32_t version)
493{
494 struct display *d = data;
495
496 if (strcmp(interface, "wl_compositor") == 0) {
497 d->compositor =
498 wl_registry_bind(registry,
499 id, &wl_compositor_interface, 1);
Jonas Ådahl42682622016-08-11 23:44:41 +0800500 } else if (strcmp(interface, "zxdg_shell_v6") == 0) {
George Kiagiadakis53868982014-06-12 16:26:49 +0200501 d->shell = wl_registry_bind(registry,
Jonas Ådahl42682622016-08-11 23:44:41 +0800502 id, &zxdg_shell_v6_interface, 1);
503 zxdg_shell_v6_add_listener(d->shell, &xdg_shell_listener, d);
Jonas Ådahl496adb32015-11-17 16:00:27 +0800504 } else if (strcmp(interface, "zwp_fullscreen_shell_v1") == 0) {
George Kiagiadakis53868982014-06-12 16:26:49 +0200505 d->fshell = wl_registry_bind(registry,
Jonas Ådahl496adb32015-11-17 16:00:27 +0800506 id, &zwp_fullscreen_shell_v1_interface, 1);
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800507 } else if (strcmp(interface, "zwp_linux_dmabuf_v1") == 0) {
George Kiagiadakis53868982014-06-12 16:26:49 +0200508 d->dmabuf = wl_registry_bind(registry,
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800509 id, &zwp_linux_dmabuf_v1_interface, 1);
510 zwp_linux_dmabuf_v1_add_listener(d->dmabuf, &dmabuf_listener, d);
George Kiagiadakis53868982014-06-12 16:26:49 +0200511 }
512}
513
514static void
515registry_handle_global_remove(void *data, struct wl_registry *registry,
516 uint32_t name)
517{
518}
519
520static const struct wl_registry_listener registry_listener = {
521 registry_handle_global,
522 registry_handle_global_remove
523};
524
525static struct display *
526create_display(void)
527{
528 struct display *display;
529
530 display = malloc(sizeof *display);
531 if (display == NULL) {
532 fprintf(stderr, "out of memory\n");
533 exit(1);
534 }
535 display->display = wl_display_connect(NULL);
536 assert(display->display);
537
538 /* XXX: fake, because the compositor does not yet advertise anything */
539 display->xrgb8888_format_found = 1;
540
541 display->registry = wl_display_get_registry(display->display);
542 wl_registry_add_listener(display->registry,
543 &registry_listener, display);
544 wl_display_roundtrip(display->display);
545 if (display->dmabuf == NULL) {
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800546 fprintf(stderr, "No zwp_linux_dmabuf global\n");
George Kiagiadakis53868982014-06-12 16:26:49 +0200547 exit(1);
548 }
549
550 wl_display_roundtrip(display->display);
551
552 if (!display->xrgb8888_format_found) {
553 fprintf(stderr, "DRM_FORMAT_XRGB8888 not available\n");
554 exit(1);
555 }
556
557 return display;
558}
559
560static void
561destroy_display(struct display *display)
562{
563 if (display->dmabuf)
Jonas Ådahl57e48f02015-11-17 16:00:28 +0800564 zwp_linux_dmabuf_v1_destroy(display->dmabuf);
George Kiagiadakis53868982014-06-12 16:26:49 +0200565
566 if (display->shell)
Jonas Ådahl42682622016-08-11 23:44:41 +0800567 zxdg_shell_v6_destroy(display->shell);
George Kiagiadakis53868982014-06-12 16:26:49 +0200568
569 if (display->fshell)
Jonas Ådahl496adb32015-11-17 16:00:27 +0800570 zwp_fullscreen_shell_v1_release(display->fshell);
George Kiagiadakis53868982014-06-12 16:26:49 +0200571
572 if (display->compositor)
573 wl_compositor_destroy(display->compositor);
574
575 wl_registry_destroy(display->registry);
576 wl_display_flush(display->display);
577 wl_display_disconnect(display->display);
578 free(display);
579}
580
581static void
582signal_int(int signum)
583{
584 running = 0;
585}
586
587int
588main(int argc, char **argv)
589{
590 struct sigaction sigint;
591 struct display *display;
592 struct window *window;
593 int ret = 0;
594
595 display = create_display();
596 window = create_window(display, 250, 250);
597 if (!window)
598 return 1;
599
600 sigint.sa_handler = signal_int;
601 sigemptyset(&sigint.sa_mask);
602 sigint.sa_flags = SA_RESETHAND;
603 sigaction(SIGINT, &sigint, NULL);
604
Emmanuel Gil Peyrot8ef29572016-01-11 19:04:37 +0000605 /* Here we retrieve the linux-dmabuf objects, or error */
606 wl_display_roundtrip(display->display);
607
608 if (!running)
609 return 1;
George Kiagiadakis53868982014-06-12 16:26:49 +0200610
Jonas Ådahl42682622016-08-11 23:44:41 +0800611 window->initialized = true;
612
613 if (!window->wait_for_configure)
614 redraw(window, NULL, 0);
George Kiagiadakis53868982014-06-12 16:26:49 +0200615
616 while (running && ret != -1)
617 ret = wl_display_dispatch(display->display);
618
619 fprintf(stderr, "simple-dmabuf exiting\n");
620 destroy_window(window);
621 destroy_display(display);
622
623 return 0;
624}