1 /**************************************************************************
2 *
3 * Copyright 2016 Advanced Micro Devices, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * 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, sub license, 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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include <fcntl.h>
29
30 #include <X11/Xlib-xcb.h>
31 #include <X11/xshmfence.h>
32 #include <xcb/dri3.h>
33 #include <xcb/present.h>
34 #include <xcb/xfixes.h>
35
36 #include "loader.h"
37
38 #include "pipe/p_screen.h"
39 #include "pipe/p_state.h"
40 #include "pipe-loader/pipe_loader.h"
41
42 #include "util/u_memory.h"
43 #include "util/u_inlines.h"
44
45 #include "vl/vl_compositor.h"
46 #include "vl/vl_winsys.h"
47
48 #include "drm-uapi/drm_fourcc.h"
49
50 #define BACK_BUFFER_NUM 3
51
52 struct vl_dri3_buffer
53 {
54 struct pipe_resource *texture;
55 struct pipe_resource *linear_texture;
56
57 uint32_t pixmap;
58 uint32_t region;
59 uint32_t sync_fence;
60 struct xshmfence *shm_fence;
61
62 bool busy;
63 uint32_t width, height, pitch;
64 };
65
66 struct vl_dri3_screen
67 {
68 struct vl_screen base;
69 xcb_connection_t *conn;
70 xcb_drawable_t drawable;
71
72 uint32_t width, height, depth;
73
74 xcb_present_event_t eid;
75 xcb_special_event_t *special_event;
76
77 struct pipe_context *pipe;
78 struct pipe_resource *output_texture;
79 uint32_t clip_width, clip_height;
80
81 struct vl_dri3_buffer *back_buffers[BACK_BUFFER_NUM];
82 int cur_back;
83 int next_back;
84
85 struct u_rect dirty_areas[BACK_BUFFER_NUM];
86
87 struct vl_dri3_buffer *front_buffer;
88 bool is_pixmap;
89
90 uint32_t send_msc_serial, recv_msc_serial;
91 uint64_t send_sbc, recv_sbc;
92 int64_t last_ust, ns_frame, last_msc, next_msc;
93
94 bool is_different_gpu;
95 };
96
97 static void
dri3_free_front_buffer(struct vl_dri3_screen * scrn,struct vl_dri3_buffer * buffer)98 dri3_free_front_buffer(struct vl_dri3_screen *scrn,
99 struct vl_dri3_buffer *buffer)
100 {
101 xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
102 xshmfence_unmap_shm(buffer->shm_fence);
103 pipe_resource_reference(&buffer->texture, NULL);
104 FREE(buffer);
105 }
106
107 static void
dri3_free_back_buffer(struct vl_dri3_screen * scrn,struct vl_dri3_buffer * buffer)108 dri3_free_back_buffer(struct vl_dri3_screen *scrn,
109 struct vl_dri3_buffer *buffer)
110 {
111 if (buffer->region)
112 xcb_xfixes_destroy_region(scrn->conn, buffer->region);
113 xcb_free_pixmap(scrn->conn, buffer->pixmap);
114 xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
115 xshmfence_unmap_shm(buffer->shm_fence);
116 if (!scrn->output_texture)
117 pipe_resource_reference(&buffer->texture, NULL);
118 if (buffer->linear_texture)
119 pipe_resource_reference(&buffer->linear_texture, NULL);
120 FREE(buffer);
121 }
122
123 static void
dri3_handle_stamps(struct vl_dri3_screen * scrn,uint64_t ust,uint64_t msc)124 dri3_handle_stamps(struct vl_dri3_screen *scrn, uint64_t ust, uint64_t msc)
125 {
126 int64_t ust_ns = ust * 1000;
127
128 if (scrn->last_ust && (ust_ns > scrn->last_ust) &&
129 scrn->last_msc && (msc > scrn->last_msc))
130 scrn->ns_frame = (ust_ns - scrn->last_ust) / (msc - scrn->last_msc);
131
132 scrn->last_ust = ust_ns;
133 scrn->last_msc = msc;
134 }
135
136 static void
dri3_handle_present_event(struct vl_dri3_screen * scrn,xcb_present_generic_event_t * ge)137 dri3_handle_present_event(struct vl_dri3_screen *scrn,
138 xcb_present_generic_event_t *ge)
139 {
140 switch (ge->evtype) {
141 case XCB_PRESENT_CONFIGURE_NOTIFY: {
142 xcb_present_configure_notify_event_t *ce = (void *) ge;
143 scrn->width = ce->width;
144 scrn->height = ce->height;
145 break;
146 }
147 case XCB_PRESENT_COMPLETE_NOTIFY: {
148 xcb_present_complete_notify_event_t *ce = (void *) ge;
149 if (ce->kind == XCB_PRESENT_COMPLETE_KIND_PIXMAP) {
150 scrn->recv_sbc = (scrn->send_sbc & 0xffffffff00000000LL) | ce->serial;
151 if (scrn->recv_sbc > scrn->send_sbc)
152 scrn->recv_sbc -= 0x100000000;
153 dri3_handle_stamps(scrn, ce->ust, ce->msc);
154 } else if (ce->kind == XCB_PRESENT_COMPLETE_KIND_NOTIFY_MSC) {
155 scrn->recv_msc_serial = ce->serial;
156 dri3_handle_stamps(scrn, ce->ust, ce->msc);
157 }
158 break;
159 }
160 case XCB_PRESENT_EVENT_IDLE_NOTIFY: {
161 xcb_present_idle_notify_event_t *ie = (void *) ge;
162 int b;
163 for (b = 0; b < BACK_BUFFER_NUM; b++) {
164 struct vl_dri3_buffer *buf = scrn->back_buffers[b];
165 if (buf && buf->pixmap == ie->pixmap) {
166 buf->busy = false;
167 break;
168 }
169 }
170 break;
171 }
172 }
173 free(ge);
174 }
175
176 static void
dri3_flush_present_events(struct vl_dri3_screen * scrn)177 dri3_flush_present_events(struct vl_dri3_screen *scrn)
178 {
179 if (scrn->special_event) {
180 xcb_generic_event_t *ev;
181 while ((ev = xcb_poll_for_special_event(
182 scrn->conn, scrn->special_event)) != NULL)
183 dri3_handle_present_event(scrn, (xcb_present_generic_event_t *)ev);
184 }
185 }
186
187 static bool
dri3_wait_present_events(struct vl_dri3_screen * scrn)188 dri3_wait_present_events(struct vl_dri3_screen *scrn)
189 {
190 if (scrn->special_event) {
191 xcb_generic_event_t *ev;
192 ev = xcb_wait_for_special_event(scrn->conn, scrn->special_event);
193 if (!ev)
194 return false;
195 dri3_handle_present_event(scrn, (xcb_present_generic_event_t *)ev);
196 return true;
197 }
198 return false;
199 }
200
201 static int
dri3_find_back(struct vl_dri3_screen * scrn)202 dri3_find_back(struct vl_dri3_screen *scrn)
203 {
204 int b;
205
206 for (;;) {
207 for (b = 0; b < BACK_BUFFER_NUM; b++) {
208 int id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
209 struct vl_dri3_buffer *buffer = scrn->back_buffers[id];
210 if (!buffer || !buffer->busy)
211 return id;
212 }
213 xcb_flush(scrn->conn);
214 if (!dri3_wait_present_events(scrn))
215 return -1;
216 }
217 }
218
219 static struct vl_dri3_buffer *
dri3_alloc_back_buffer(struct vl_dri3_screen * scrn)220 dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
221 {
222 struct vl_dri3_buffer *buffer;
223 xcb_pixmap_t pixmap;
224 xcb_sync_fence_t sync_fence;
225 struct xshmfence *shm_fence;
226 int buffer_fd, fence_fd;
227 struct pipe_resource templ, *pixmap_buffer_texture;
228 struct winsys_handle whandle;
229
230 buffer = CALLOC_STRUCT(vl_dri3_buffer);
231 if (!buffer)
232 return NULL;
233
234 fence_fd = xshmfence_alloc_shm();
235 if (fence_fd < 0)
236 goto free_buffer;
237
238 shm_fence = xshmfence_map_shm(fence_fd);
239 if (!shm_fence)
240 goto close_fd;
241
242 memset(&templ, 0, sizeof(templ));
243 templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
244 templ.format = vl_dri2_format_for_depth(&scrn->base, scrn->depth);
245 templ.target = PIPE_TEXTURE_2D;
246 templ.last_level = 0;
247 templ.width0 = (scrn->output_texture) ?
248 scrn->output_texture->width0 : scrn->width;
249 templ.height0 = (scrn->output_texture) ?
250 scrn->output_texture->height0 : scrn->height;
251 templ.depth0 = 1;
252 templ.array_size = 1;
253
254 if (scrn->is_different_gpu) {
255 buffer->texture = (scrn->output_texture) ? scrn->output_texture :
256 scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
257 if (!buffer->texture)
258 goto unmap_shm;
259
260 templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED |
261 PIPE_BIND_LINEAR;
262 buffer->linear_texture =
263 scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
264 pixmap_buffer_texture = buffer->linear_texture;
265
266 if (!buffer->linear_texture)
267 goto no_linear_texture;
268 } else {
269 templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED;
270 buffer->texture = (scrn->output_texture) ? scrn->output_texture :
271 scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
272 if (!buffer->texture)
273 goto unmap_shm;
274 pixmap_buffer_texture = buffer->texture;
275 }
276 memset(&whandle, 0, sizeof(whandle));
277 whandle.type= WINSYS_HANDLE_TYPE_FD;
278 scrn->base.pscreen->resource_get_handle(scrn->base.pscreen, NULL,
279 pixmap_buffer_texture, &whandle, 0);
280 buffer_fd = whandle.handle;
281 buffer->pitch = whandle.stride;
282 buffer->width = templ.width0;
283 buffer->height = templ.height0;
284
285 xcb_dri3_pixmap_from_buffer(scrn->conn,
286 (pixmap = xcb_generate_id(scrn->conn)),
287 scrn->drawable,
288 0,
289 buffer->width, buffer->height, buffer->pitch,
290 scrn->depth, 32,
291 buffer_fd);
292 xcb_dri3_fence_from_fd(scrn->conn,
293 pixmap,
294 (sync_fence = xcb_generate_id(scrn->conn)),
295 false,
296 fence_fd);
297
298 buffer->pixmap = pixmap;
299 buffer->sync_fence = sync_fence;
300 buffer->shm_fence = shm_fence;
301
302 xshmfence_trigger(buffer->shm_fence);
303
304 return buffer;
305
306 no_linear_texture:
307 pipe_resource_reference(&buffer->texture, NULL);
308 unmap_shm:
309 xshmfence_unmap_shm(shm_fence);
310 close_fd:
311 close(fence_fd);
312 free_buffer:
313 FREE(buffer);
314 return NULL;
315 }
316
317 static struct vl_dri3_buffer *
dri3_get_back_buffer(struct vl_dri3_screen * scrn)318 dri3_get_back_buffer(struct vl_dri3_screen *scrn)
319 {
320 struct vl_dri3_buffer *buffer;
321 struct pipe_resource *texture = NULL;
322 bool allocate_new_buffer = false;
323 int b, id;
324
325 assert(scrn);
326
327 scrn->cur_back = dri3_find_back(scrn);
328 if (scrn->cur_back < 0)
329 return NULL;
330 buffer = scrn->back_buffers[scrn->cur_back];
331
332 if (scrn->output_texture) {
333 if (!buffer || buffer->width < scrn->width ||
334 buffer->height < scrn->height)
335 allocate_new_buffer = true;
336 else if (scrn->is_different_gpu)
337 /* In case of different gpu we can reuse the linear
338 * texture so we only need to set the external
339 * texture for copying
340 */
341 buffer->texture = scrn->output_texture;
342 else {
343 /* In case of a single gpu we search if the texture is
344 * already present as buffer if not we get the
345 * handle and pixmap for the texture that is set
346 */
347 for (b = 0; b < BACK_BUFFER_NUM; b++) {
348 id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
349 buffer = scrn->back_buffers[id];
350 if (buffer && !buffer->busy &&
351 buffer->texture == scrn->output_texture) {
352 scrn->cur_back = id;
353 break;
354 }
355 }
356
357 if (b == BACK_BUFFER_NUM) {
358 allocate_new_buffer = true;
359 scrn->cur_back = scrn->next_back;
360 scrn->next_back = (scrn->next_back + 1) % BACK_BUFFER_NUM;
361 buffer = scrn->back_buffers[scrn->cur_back];
362 }
363 }
364
365 } else {
366 if (!buffer || buffer->width != scrn->width ||
367 buffer->height != scrn->height)
368 allocate_new_buffer = true;
369 }
370
371 if (allocate_new_buffer) {
372 struct vl_dri3_buffer *new_buffer;
373
374 new_buffer = dri3_alloc_back_buffer(scrn);
375 if (!new_buffer)
376 return NULL;
377
378 if (buffer)
379 dri3_free_back_buffer(scrn, buffer);
380
381 if (!scrn->output_texture)
382 vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
383 buffer = new_buffer;
384 scrn->back_buffers[scrn->cur_back] = buffer;
385 }
386
387 pipe_resource_reference(&texture, buffer->texture);
388 xcb_flush(scrn->conn);
389 xshmfence_await(buffer->shm_fence);
390
391 return buffer;
392 }
393
394 static bool
dri3_set_drawable(struct vl_dri3_screen * scrn,Drawable drawable)395 dri3_set_drawable(struct vl_dri3_screen *scrn, Drawable drawable)
396 {
397 xcb_get_geometry_cookie_t geom_cookie;
398 xcb_get_geometry_reply_t *geom_reply;
399 xcb_void_cookie_t cookie;
400 xcb_generic_error_t *error;
401 bool ret = true;
402
403 assert(drawable);
404
405 if (scrn->drawable == drawable)
406 return true;
407
408 scrn->drawable = drawable;
409
410 geom_cookie = xcb_get_geometry(scrn->conn, scrn->drawable);
411 geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
412 if (!geom_reply)
413 return false;
414
415 scrn->width = geom_reply->width;
416 scrn->height = geom_reply->height;
417 scrn->depth = geom_reply->depth;
418 free(geom_reply);
419
420 if (scrn->special_event) {
421 xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
422 scrn->special_event = NULL;
423 cookie = xcb_present_select_input_checked(scrn->conn, scrn->eid,
424 scrn->drawable,
425 XCB_PRESENT_EVENT_MASK_NO_EVENT);
426 xcb_discard_reply(scrn->conn, cookie.sequence);
427 }
428
429 scrn->is_pixmap = false;
430 scrn->eid = xcb_generate_id(scrn->conn);
431 cookie =
432 xcb_present_select_input_checked(scrn->conn, scrn->eid, scrn->drawable,
433 XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY |
434 XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY |
435 XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY);
436
437 error = xcb_request_check(scrn->conn, cookie);
438 if (error) {
439 if (error->error_code != BadWindow)
440 ret = false;
441 else {
442 scrn->is_pixmap = true;
443 scrn->base.set_back_texture_from_output = NULL;
444 if (scrn->front_buffer) {
445 dri3_free_front_buffer(scrn, scrn->front_buffer);
446 scrn->front_buffer = NULL;
447 }
448 }
449 free(error);
450 } else
451 scrn->special_event =
452 xcb_register_for_special_xge(scrn->conn, &xcb_present_id, scrn->eid, 0);
453
454 dri3_flush_present_events(scrn);
455
456 return ret;
457 }
458
459 static struct vl_dri3_buffer *
dri3_get_front_buffer(struct vl_dri3_screen * scrn)460 dri3_get_front_buffer(struct vl_dri3_screen *scrn)
461 {
462 xcb_dri3_buffer_from_pixmap_cookie_t bp_cookie;
463 xcb_dri3_buffer_from_pixmap_reply_t *bp_reply;
464 xcb_sync_fence_t sync_fence;
465 struct xshmfence *shm_fence;
466 int fence_fd, *fds;
467 struct winsys_handle whandle;
468 struct pipe_resource templ, *texture = NULL;
469
470 if (scrn->front_buffer) {
471 pipe_resource_reference(&texture, scrn->front_buffer->texture);
472 return scrn->front_buffer;
473 }
474
475 scrn->front_buffer = CALLOC_STRUCT(vl_dri3_buffer);
476 if (!scrn->front_buffer)
477 return NULL;
478
479 fence_fd = xshmfence_alloc_shm();
480 if (fence_fd < 0)
481 goto free_buffer;
482
483 shm_fence = xshmfence_map_shm(fence_fd);
484 if (!shm_fence)
485 goto close_fd;
486
487 bp_cookie = xcb_dri3_buffer_from_pixmap(scrn->conn, scrn->drawable);
488 bp_reply = xcb_dri3_buffer_from_pixmap_reply(scrn->conn, bp_cookie, NULL);
489 if (!bp_reply)
490 goto unmap_shm;
491
492 fds = xcb_dri3_buffer_from_pixmap_reply_fds(scrn->conn, bp_reply);
493 if (fds[0] < 0)
494 goto free_reply;
495
496 memset(&whandle, 0, sizeof(whandle));
497 whandle.type = WINSYS_HANDLE_TYPE_FD;
498 whandle.handle = (unsigned)fds[0];
499 whandle.stride = bp_reply->stride;
500 whandle.modifier = DRM_FORMAT_MOD_INVALID;
501 memset(&templ, 0, sizeof(templ));
502 templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
503 templ.format = vl_dri2_format_for_depth(&scrn->base, bp_reply->depth);
504 templ.target = PIPE_TEXTURE_2D;
505 templ.last_level = 0;
506 templ.width0 = bp_reply->width;
507 templ.height0 = bp_reply->height;
508 templ.depth0 = 1;
509 templ.array_size = 1;
510 scrn->front_buffer->texture =
511 scrn->base.pscreen->resource_from_handle(scrn->base.pscreen,
512 &templ, &whandle,
513 PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE);
514 close(fds[0]);
515 if (!scrn->front_buffer->texture)
516 goto free_reply;
517
518 xcb_dri3_fence_from_fd(scrn->conn,
519 scrn->drawable,
520 (sync_fence = xcb_generate_id(scrn->conn)),
521 false,
522 fence_fd);
523
524 pipe_resource_reference(&texture, scrn->front_buffer->texture);
525 scrn->front_buffer->pixmap = scrn->drawable;
526 scrn->front_buffer->width = bp_reply->width;
527 scrn->front_buffer->height = bp_reply->height;
528 scrn->front_buffer->shm_fence = shm_fence;
529 scrn->front_buffer->sync_fence = sync_fence;
530 free(bp_reply);
531
532 return scrn->front_buffer;
533
534 free_reply:
535 free(bp_reply);
536 unmap_shm:
537 xshmfence_unmap_shm(shm_fence);
538 close_fd:
539 close(fence_fd);
540 free_buffer:
541 FREE(scrn->front_buffer);
542 return NULL;
543 }
544
545 static xcb_screen_t *
dri3_get_screen_for_root(xcb_connection_t * conn,xcb_window_t root)546 dri3_get_screen_for_root(xcb_connection_t *conn, xcb_window_t root)
547 {
548 xcb_screen_iterator_t screen_iter =
549 xcb_setup_roots_iterator(xcb_get_setup(conn));
550
551 for (; screen_iter.rem; xcb_screen_next (&screen_iter)) {
552 if (screen_iter.data->root == root)
553 return screen_iter.data;
554 }
555
556 return NULL;
557 }
558
559 static void
vl_dri3_flush_frontbuffer(struct pipe_screen * screen,struct pipe_context * pipe,struct pipe_resource * resource,unsigned level,unsigned layer,void * context_private,struct pipe_box * sub_box)560 vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
561 struct pipe_context *pipe,
562 struct pipe_resource *resource,
563 unsigned level, unsigned layer,
564 void *context_private, struct pipe_box *sub_box)
565 {
566 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)context_private;
567 uint32_t options = XCB_PRESENT_OPTION_NONE;
568 struct vl_dri3_buffer *back;
569 struct pipe_box src_box;
570 xcb_rectangle_t rectangle;
571
572 back = scrn->back_buffers[scrn->cur_back];
573 if (!back)
574 return;
575
576 while (scrn->special_event && scrn->recv_sbc < scrn->send_sbc)
577 if (!dri3_wait_present_events(scrn))
578 return;
579
580 rectangle.x = 0;
581 rectangle.y = 0;
582 rectangle.width = (scrn->output_texture) ? scrn->clip_width : scrn->width;
583 rectangle.height = (scrn->output_texture) ? scrn->clip_height : scrn->height;
584
585 if (!back->region) {
586 back->region = xcb_generate_id(scrn->conn);
587 xcb_xfixes_create_region(scrn->conn, back->region, 0, NULL);
588 }
589 xcb_xfixes_set_region(scrn->conn, back->region, 1, &rectangle);
590
591 if (scrn->is_different_gpu) {
592 u_box_origin_2d(back->width, back->height, &src_box);
593 scrn->pipe->resource_copy_region(scrn->pipe,
594 back->linear_texture,
595 0, 0, 0, 0,
596 back->texture,
597 0, &src_box);
598
599 scrn->pipe->flush(scrn->pipe, NULL, 0);
600 }
601 xshmfence_reset(back->shm_fence);
602 back->busy = true;
603
604 xcb_present_pixmap(scrn->conn,
605 scrn->drawable,
606 back->pixmap,
607 (uint32_t)(++scrn->send_sbc),
608 0, back->region, 0, 0,
609 None, None,
610 back->sync_fence,
611 options,
612 scrn->next_msc,
613 0, 0, 0, NULL);
614
615 xcb_flush(scrn->conn);
616
617 return;
618 }
619
620 static struct pipe_resource *
vl_dri3_screen_texture_from_drawable(struct vl_screen * vscreen,void * drawable)621 vl_dri3_screen_texture_from_drawable(struct vl_screen *vscreen, void *drawable)
622 {
623 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
624 struct vl_dri3_buffer *buffer;
625
626 assert(scrn);
627
628 if (!dri3_set_drawable(scrn, (Drawable)drawable))
629 return NULL;
630
631 buffer = (scrn->is_pixmap) ?
632 dri3_get_front_buffer(scrn) :
633 dri3_get_back_buffer(scrn);
634 if (!buffer)
635 return NULL;
636
637 return buffer->texture;
638 }
639
640 static struct u_rect *
vl_dri3_screen_get_dirty_area(struct vl_screen * vscreen)641 vl_dri3_screen_get_dirty_area(struct vl_screen *vscreen)
642 {
643 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
644
645 assert(scrn);
646
647 return &scrn->dirty_areas[scrn->cur_back];
648 }
649
650 static uint64_t
vl_dri3_screen_get_timestamp(struct vl_screen * vscreen,void * drawable)651 vl_dri3_screen_get_timestamp(struct vl_screen *vscreen, void *drawable)
652 {
653 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
654
655 assert(scrn);
656
657 if (!dri3_set_drawable(scrn, (Drawable)drawable))
658 return 0;
659
660 if (!scrn->last_ust) {
661 xcb_present_notify_msc(scrn->conn,
662 scrn->drawable,
663 ++scrn->send_msc_serial,
664 0, 0, 0);
665 xcb_flush(scrn->conn);
666
667 while (scrn->special_event &&
668 scrn->send_msc_serial > scrn->recv_msc_serial) {
669 if (!dri3_wait_present_events(scrn))
670 return 0;
671 }
672 }
673
674 return scrn->last_ust;
675 }
676
677 static void
vl_dri3_screen_set_next_timestamp(struct vl_screen * vscreen,uint64_t stamp)678 vl_dri3_screen_set_next_timestamp(struct vl_screen *vscreen, uint64_t stamp)
679 {
680 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
681
682 assert(scrn);
683
684 if (stamp && scrn->last_ust && scrn->ns_frame && scrn->last_msc)
685 scrn->next_msc = ((int64_t)stamp - scrn->last_ust + scrn->ns_frame/2) /
686 scrn->ns_frame + scrn->last_msc;
687 else
688 scrn->next_msc = 0;
689 }
690
691 static void *
vl_dri3_screen_get_private(struct vl_screen * vscreen)692 vl_dri3_screen_get_private(struct vl_screen *vscreen)
693 {
694 return vscreen;
695 }
696
697 static void
vl_dri3_screen_set_back_texture_from_output(struct vl_screen * vscreen,struct pipe_resource * buffer,uint32_t width,uint32_t height)698 vl_dri3_screen_set_back_texture_from_output(struct vl_screen *vscreen,
699 struct pipe_resource *buffer,
700 uint32_t width, uint32_t height)
701 {
702 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
703
704 assert(scrn);
705
706 scrn->output_texture = buffer;
707 scrn->clip_width = (width) ? width : scrn->width;
708 scrn->clip_height = (height) ? height : scrn->height;
709 }
710
711 static void
vl_dri3_screen_destroy(struct vl_screen * vscreen)712 vl_dri3_screen_destroy(struct vl_screen *vscreen)
713 {
714 struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
715 int i;
716
717 assert(vscreen);
718
719 dri3_flush_present_events(scrn);
720
721 if (scrn->front_buffer) {
722 dri3_free_front_buffer(scrn, scrn->front_buffer);
723 scrn->front_buffer = NULL;
724 }
725
726 for (i = 0; i < BACK_BUFFER_NUM; ++i) {
727 if (scrn->back_buffers[i]) {
728 dri3_free_back_buffer(scrn, scrn->back_buffers[i]);
729 scrn->back_buffers[i] = NULL;
730 }
731 }
732
733 if (scrn->special_event) {
734 xcb_void_cookie_t cookie =
735 xcb_present_select_input_checked(scrn->conn, scrn->eid,
736 scrn->drawable,
737 XCB_PRESENT_EVENT_MASK_NO_EVENT);
738
739 xcb_discard_reply(scrn->conn, cookie.sequence);
740 xcb_unregister_for_special_event(scrn->conn, scrn->special_event);
741 }
742 scrn->pipe->destroy(scrn->pipe);
743 scrn->base.pscreen->destroy(scrn->base.pscreen);
744 pipe_loader_release(&scrn->base.dev, 1);
745 FREE(scrn);
746
747 return;
748 }
749
750 struct vl_screen *
vl_dri3_screen_create(Display * display,int screen)751 vl_dri3_screen_create(Display *display, int screen)
752 {
753 struct vl_dri3_screen *scrn;
754 const xcb_query_extension_reply_t *extension;
755 xcb_dri3_open_cookie_t open_cookie;
756 xcb_dri3_open_reply_t *open_reply;
757 xcb_get_geometry_cookie_t geom_cookie;
758 xcb_get_geometry_reply_t *geom_reply;
759 xcb_xfixes_query_version_cookie_t xfixes_cookie;
760 xcb_xfixes_query_version_reply_t *xfixes_reply;
761 xcb_generic_error_t *error;
762 int fd;
763
764 assert(display);
765
766 scrn = CALLOC_STRUCT(vl_dri3_screen);
767 if (!scrn)
768 return NULL;
769
770 scrn->conn = XGetXCBConnection(display);
771 if (!scrn->conn)
772 goto free_screen;
773
774 xcb_prefetch_extension_data(scrn->conn , &xcb_dri3_id);
775 xcb_prefetch_extension_data(scrn->conn, &xcb_present_id);
776 xcb_prefetch_extension_data (scrn->conn, &xcb_xfixes_id);
777 extension = xcb_get_extension_data(scrn->conn, &xcb_dri3_id);
778 if (!(extension && extension->present))
779 goto free_screen;
780 extension = xcb_get_extension_data(scrn->conn, &xcb_present_id);
781 if (!(extension && extension->present))
782 goto free_screen;
783 extension = xcb_get_extension_data(scrn->conn, &xcb_xfixes_id);
784 if (!(extension && extension->present))
785 goto free_screen;
786
787 xfixes_cookie = xcb_xfixes_query_version(scrn->conn, XCB_XFIXES_MAJOR_VERSION,
788 XCB_XFIXES_MINOR_VERSION);
789 xfixes_reply = xcb_xfixes_query_version_reply(scrn->conn, xfixes_cookie, &error);
790 if (!xfixes_reply || error || xfixes_reply->major_version < 2) {
791 free(error);
792 free(xfixes_reply);
793 goto free_screen;
794 }
795 free(xfixes_reply);
796
797 open_cookie = xcb_dri3_open(scrn->conn, RootWindow(display, screen), None);
798 open_reply = xcb_dri3_open_reply(scrn->conn, open_cookie, NULL);
799 if (!open_reply)
800 goto free_screen;
801 if (open_reply->nfd != 1) {
802 free(open_reply);
803 goto free_screen;
804 }
805
806 fd = xcb_dri3_open_reply_fds(scrn->conn, open_reply)[0];
807 if (fd < 0) {
808 free(open_reply);
809 goto free_screen;
810 }
811 fcntl(fd, F_SETFD, FD_CLOEXEC);
812 free(open_reply);
813
814 fd = loader_get_user_preferred_fd(fd, &scrn->is_different_gpu);
815
816 geom_cookie = xcb_get_geometry(scrn->conn, RootWindow(display, screen));
817 geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
818 if (!geom_reply)
819 goto close_fd;
820
821 scrn->base.xcb_screen = dri3_get_screen_for_root(scrn->conn, geom_reply->root);
822 if (!scrn->base.xcb_screen) {
823 free(geom_reply);
824 goto close_fd;
825 }
826
827 /* TODO support depth other than 24 or 30 */
828 if (geom_reply->depth != 24 && geom_reply->depth != 30) {
829 free(geom_reply);
830 goto close_fd;
831 }
832 scrn->base.color_depth = geom_reply->depth;
833 free(geom_reply);
834
835 if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
836 scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
837
838 if (!scrn->base.pscreen)
839 goto release_pipe;
840
841 scrn->pipe = pipe_create_multimedia_context(scrn->base.pscreen);
842 if (!scrn->pipe)
843 goto no_context;
844
845 scrn->base.destroy = vl_dri3_screen_destroy;
846 scrn->base.texture_from_drawable = vl_dri3_screen_texture_from_drawable;
847 scrn->base.get_dirty_area = vl_dri3_screen_get_dirty_area;
848 scrn->base.get_timestamp = vl_dri3_screen_get_timestamp;
849 scrn->base.set_next_timestamp = vl_dri3_screen_set_next_timestamp;
850 scrn->base.get_private = vl_dri3_screen_get_private;
851 scrn->base.pscreen->flush_frontbuffer = vl_dri3_flush_frontbuffer;
852 scrn->base.set_back_texture_from_output = vl_dri3_screen_set_back_texture_from_output;
853
854 scrn->next_back = 1;
855
856 close(fd);
857
858 return &scrn->base;
859
860 no_context:
861 scrn->base.pscreen->destroy(scrn->base.pscreen);
862 release_pipe:
863 if (scrn->base.dev) {
864 pipe_loader_release(&scrn->base.dev, 1);
865 fd = -1;
866 }
867 close_fd:
868 if (fd != -1)
869 close(fd);
870 free_screen:
871 FREE(scrn);
872 return NULL;
873 }
874