1 /*
2 * Copyright © 2008 Red Hat, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Soft-
6 * ware"), to deal in the Software without restriction, including without
7 * limitation the rights to use, copy, modify, merge, publish, distribute,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, provided that the above copyright
10 * notice(s) and this permission notice appear in all copies of the Soft-
11 * ware and that both the above copyright notice(s) and this permission
12 * notice appear in supporting documentation.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
16 * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
17 * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
18 * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
19 * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
22 * MANCE OF THIS SOFTWARE.
23 *
24 * Except as contained in this notice, the name of a copyright holder shall
25 * not be used in advertising or otherwise to promote the sale, use or
26 * other dealings in this Software without prior written authorization of
27 * the copyright holder.
28 *
29 * Authors:
30 * Kristian Høgsberg (krh@redhat.com)
31 */
32
33 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
34
35 #include <X11/Xlib.h>
36 #include <X11/extensions/Xfixes.h>
37 #include <X11/Xlib-xcb.h>
38 #include <xcb/xcb.h>
39 #include <xcb/dri2.h>
40 #include "glxclient.h"
41 #include <X11/extensions/dri2proto.h>
42 #include <dlfcn.h>
43 #include <fcntl.h>
44 #include <unistd.h>
45 #include <sys/types.h>
46 #include <sys/mman.h>
47 #include <sys/time.h>
48 #include "dri2.h"
49 #include "dri_common.h"
50 #include "dri2_priv.h"
51 #include "loader.h"
52
53 /* From driconf.h, user exposed so should be stable */
54 #define DRI_CONF_VBLANK_NEVER 0
55 #define DRI_CONF_VBLANK_DEF_INTERVAL_0 1
56 #define DRI_CONF_VBLANK_DEF_INTERVAL_1 2
57 #define DRI_CONF_VBLANK_ALWAYS_SYNC 3
58
59 #undef DRI2_MINOR
60 #define DRI2_MINOR 1
61
62 struct dri2_display
63 {
64 __GLXDRIdisplay base;
65
66 /*
67 ** XFree86-DRI version information
68 */
69 int driMajor;
70 int driMinor;
71 int driPatch;
72 int swapAvailable;
73 int invalidateAvailable;
74
75 __glxHashTable *dri2Hash;
76
77 const __DRIextension *loader_extensions[5];
78 };
79
80 struct dri2_drawable
81 {
82 __GLXDRIdrawable base;
83 __DRIdrawable *driDrawable;
84 __DRIbuffer buffers[5];
85 int bufferCount;
86 int width, height;
87 int have_back;
88 int have_fake_front;
89 int swap_interval;
90
91 uint64_t previous_time;
92 unsigned frames;
93 };
94
95 static const struct glx_context_vtable dri2_context_vtable;
96
97 /* For XCB's handling of ust/msc/sbc counters, we have to hand it the high and
98 * low halves separately. This helps you split them.
99 */
100 static void
split_counter(uint64_t counter,uint32_t * hi,uint32_t * lo)101 split_counter(uint64_t counter, uint32_t *hi, uint32_t *lo)
102 {
103 *hi = (counter >> 32);
104 *lo = counter & 0xffffffff;
105 }
106
107 static uint64_t
merge_counter(uint32_t hi,uint32_t lo)108 merge_counter(uint32_t hi, uint32_t lo)
109 {
110 return ((uint64_t)hi << 32) | lo;
111 }
112
113 static void
dri2_destroy_context(struct glx_context * context)114 dri2_destroy_context(struct glx_context *context)
115 {
116 struct dri2_context *pcp = (struct dri2_context *) context;
117 struct dri2_screen *psc = (struct dri2_screen *) context->psc;
118
119 driReleaseDrawables(&pcp->base);
120
121 free((char *) context->extensions);
122
123 (*psc->core->destroyContext) (pcp->driContext);
124
125 free(pcp);
126 }
127
128 static Bool
dri2_bind_context(struct glx_context * context,struct glx_context * old,GLXDrawable draw,GLXDrawable read)129 dri2_bind_context(struct glx_context *context, struct glx_context *old,
130 GLXDrawable draw, GLXDrawable read)
131 {
132 struct dri2_context *pcp = (struct dri2_context *) context;
133 struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc;
134 struct dri2_drawable *pdraw, *pread;
135 __DRIdrawable *dri_draw = NULL, *dri_read = NULL;
136 struct glx_display *dpyPriv = psc->base.display;
137 struct dri2_display *pdp;
138
139 pdraw = (struct dri2_drawable *) driFetchDrawable(context, draw);
140 pread = (struct dri2_drawable *) driFetchDrawable(context, read);
141
142 driReleaseDrawables(&pcp->base);
143
144 if (pdraw)
145 dri_draw = pdraw->driDrawable;
146 else if (draw != None)
147 return GLXBadDrawable;
148
149 if (pread)
150 dri_read = pread->driDrawable;
151 else if (read != None)
152 return GLXBadDrawable;
153
154 if (!(*psc->core->bindContext) (pcp->driContext, dri_draw, dri_read))
155 return GLXBadContext;
156
157 /* If the server doesn't send invalidate events, we may miss a
158 * resize before the rendering starts. Invalidate the buffers now
159 * so the driver will recheck before rendering starts. */
160 pdp = (struct dri2_display *) dpyPriv->dri2Display;
161 if (!pdp->invalidateAvailable && pdraw) {
162 dri2InvalidateBuffers(psc->base.dpy, pdraw->base.xDrawable);
163 if (pread != pdraw && pread)
164 dri2InvalidateBuffers(psc->base.dpy, pread->base.xDrawable);
165 }
166
167 return Success;
168 }
169
170 static void
dri2_unbind_context(struct glx_context * context,struct glx_context * new)171 dri2_unbind_context(struct glx_context *context, struct glx_context *new)
172 {
173 struct dri2_context *pcp = (struct dri2_context *) context;
174 struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc;
175
176 (*psc->core->unbindContext) (pcp->driContext);
177 }
178
179 static struct glx_context *
dri2_create_context(struct glx_screen * base,struct glx_config * config_base,struct glx_context * shareList,int renderType)180 dri2_create_context(struct glx_screen *base,
181 struct glx_config *config_base,
182 struct glx_context *shareList, int renderType)
183 {
184 struct dri2_context *pcp, *pcp_shared;
185 struct dri2_screen *psc = (struct dri2_screen *) base;
186 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
187 __DRIcontext *shared = NULL;
188
189 /* Check the renderType value */
190 if (!validate_renderType_against_config(config_base, renderType))
191 return NULL;
192
193 if (shareList) {
194 /* If the shareList context is not a DRI2 context, we cannot possibly
195 * create a DRI2 context that shares it.
196 */
197 if (shareList->vtable->destroy != dri2_destroy_context) {
198 return NULL;
199 }
200
201 pcp_shared = (struct dri2_context *) shareList;
202 shared = pcp_shared->driContext;
203 }
204
205 pcp = calloc(1, sizeof *pcp);
206 if (pcp == NULL)
207 return NULL;
208
209 if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
210 free(pcp);
211 return NULL;
212 }
213
214 pcp->base.renderType = renderType;
215
216 pcp->driContext =
217 (*psc->dri2->createNewContext) (psc->driScreen,
218 config->driConfig, shared, pcp);
219
220 if (pcp->driContext == NULL) {
221 free(pcp);
222 return NULL;
223 }
224
225 pcp->base.vtable = &dri2_context_vtable;
226
227 return &pcp->base;
228 }
229
230 static struct glx_context *
dri2_create_context_attribs(struct glx_screen * base,struct glx_config * config_base,struct glx_context * shareList,unsigned num_attribs,const uint32_t * attribs,unsigned * error)231 dri2_create_context_attribs(struct glx_screen *base,
232 struct glx_config *config_base,
233 struct glx_context *shareList,
234 unsigned num_attribs,
235 const uint32_t *attribs,
236 unsigned *error)
237 {
238 struct dri2_context *pcp = NULL;
239 struct dri2_context *pcp_shared = NULL;
240 struct dri2_screen *psc = (struct dri2_screen *) base;
241 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
242 __DRIcontext *shared = NULL;
243
244 uint32_t minor_ver;
245 uint32_t major_ver;
246 uint32_t renderType;
247 uint32_t flags;
248 unsigned api;
249 int reset;
250 int release;
251 uint32_t ctx_attribs[2 * 6];
252 unsigned num_ctx_attribs = 0;
253
254 if (psc->dri2->base.version < 3) {
255 *error = __DRI_CTX_ERROR_NO_MEMORY;
256 goto error_exit;
257 }
258
259 /* Remap the GLX tokens to DRI2 tokens.
260 */
261 if (!dri2_convert_glx_attribs(num_attribs, attribs,
262 &major_ver, &minor_ver, &renderType, &flags,
263 &api, &reset, &release, error))
264 goto error_exit;
265
266 if (!dri2_check_no_error(flags, shareList, major_ver, error)) {
267 goto error_exit;
268 }
269
270 /* Check the renderType value */
271 if (!validate_renderType_against_config(config_base, renderType))
272 goto error_exit;
273
274 if (shareList) {
275 pcp_shared = (struct dri2_context *) shareList;
276 shared = pcp_shared->driContext;
277 }
278
279 pcp = calloc(1, sizeof *pcp);
280 if (pcp == NULL) {
281 *error = __DRI_CTX_ERROR_NO_MEMORY;
282 goto error_exit;
283 }
284
285 if (!glx_context_init(&pcp->base, &psc->base, config_base))
286 goto error_exit;
287
288 ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
289 ctx_attribs[num_ctx_attribs++] = major_ver;
290 ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
291 ctx_attribs[num_ctx_attribs++] = minor_ver;
292
293 /* Only send a value when the non-default value is requested. By doing
294 * this we don't have to check the driver's DRI2 version before sending the
295 * default value.
296 */
297 if (reset != __DRI_CTX_RESET_NO_NOTIFICATION) {
298 ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
299 ctx_attribs[num_ctx_attribs++] = reset;
300 }
301
302 if (release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH) {
303 ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR;
304 ctx_attribs[num_ctx_attribs++] = release;
305 }
306
307 if (flags != 0) {
308 ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
309
310 /* The current __DRI_CTX_FLAG_* values are identical to the
311 * GLX_CONTEXT_*_BIT values.
312 */
313 ctx_attribs[num_ctx_attribs++] = flags;
314 }
315
316 /* The renderType is retrieved from attribs, or set to default
317 * of GLX_RGBA_TYPE.
318 */
319 pcp->base.renderType = renderType;
320
321 if (flags & __DRI_CTX_FLAG_NO_ERROR)
322 pcp->base.noError = GL_TRUE;
323
324 pcp->driContext =
325 (*psc->dri2->createContextAttribs) (psc->driScreen,
326 api,
327 config ? config->driConfig : NULL,
328 shared,
329 num_ctx_attribs / 2,
330 ctx_attribs,
331 error,
332 pcp);
333
334 if (pcp->driContext == NULL)
335 goto error_exit;
336
337 pcp->base.vtable = &dri2_context_vtable;
338
339 return &pcp->base;
340
341 error_exit:
342 free(pcp);
343
344 return NULL;
345 }
346
347 static void
dri2DestroyDrawable(__GLXDRIdrawable * base)348 dri2DestroyDrawable(__GLXDRIdrawable *base)
349 {
350 struct dri2_screen *psc = (struct dri2_screen *) base->psc;
351 struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
352 struct glx_display *dpyPriv = psc->base.display;
353 struct dri2_display *pdp = (struct dri2_display *)dpyPriv->dri2Display;
354
355 __glxHashDelete(pdp->dri2Hash, pdraw->base.xDrawable);
356 (*psc->core->destroyDrawable) (pdraw->driDrawable);
357
358 /* If it's a GLX 1.3 drawables, we can destroy the DRI2 drawable
359 * now, as the application explicitly asked to destroy the GLX
360 * drawable. Otherwise, for legacy drawables, we let the DRI2
361 * drawable linger on the server, since there's no good way of
362 * knowing when the application is done with it. The server will
363 * destroy the DRI2 drawable when it destroys the X drawable or the
364 * client exits anyway. */
365 if (pdraw->base.xDrawable != pdraw->base.drawable)
366 DRI2DestroyDrawable(psc->base.dpy, pdraw->base.xDrawable);
367
368 free(pdraw);
369 }
370
371 static __GLXDRIdrawable *
dri2CreateDrawable(struct glx_screen * base,XID xDrawable,GLXDrawable drawable,struct glx_config * config_base)372 dri2CreateDrawable(struct glx_screen *base, XID xDrawable,
373 GLXDrawable drawable, struct glx_config *config_base)
374 {
375 struct dri2_drawable *pdraw;
376 struct dri2_screen *psc = (struct dri2_screen *) base;
377 __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
378 struct glx_display *dpyPriv;
379 struct dri2_display *pdp;
380 GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
381
382 dpyPriv = __glXInitialize(psc->base.dpy);
383 if (dpyPriv == NULL)
384 return NULL;
385
386 pdraw = calloc(1, sizeof(*pdraw));
387 if (!pdraw)
388 return NULL;
389
390 pdraw->base.destroyDrawable = dri2DestroyDrawable;
391 pdraw->base.xDrawable = xDrawable;
392 pdraw->base.drawable = drawable;
393 pdraw->base.psc = &psc->base;
394 pdraw->bufferCount = 0;
395 pdraw->swap_interval = 1; /* default may be overridden below */
396 pdraw->have_back = 0;
397
398 if (psc->config)
399 psc->config->configQueryi(psc->driScreen,
400 "vblank_mode", &vblank_mode);
401
402 switch (vblank_mode) {
403 case DRI_CONF_VBLANK_NEVER:
404 case DRI_CONF_VBLANK_DEF_INTERVAL_0:
405 pdraw->swap_interval = 0;
406 break;
407 case DRI_CONF_VBLANK_DEF_INTERVAL_1:
408 case DRI_CONF_VBLANK_ALWAYS_SYNC:
409 default:
410 pdraw->swap_interval = 1;
411 break;
412 }
413
414 DRI2CreateDrawable(psc->base.dpy, xDrawable);
415 pdp = (struct dri2_display *)dpyPriv->dri2Display;
416 /* Create a new drawable */
417 pdraw->driDrawable =
418 (*psc->dri2->createNewDrawable) (psc->driScreen,
419 config->driConfig, pdraw);
420
421 if (!pdraw->driDrawable) {
422 DRI2DestroyDrawable(psc->base.dpy, xDrawable);
423 free(pdraw);
424 return NULL;
425 }
426
427 if (__glxHashInsert(pdp->dri2Hash, xDrawable, pdraw)) {
428 (*psc->core->destroyDrawable) (pdraw->driDrawable);
429 DRI2DestroyDrawable(psc->base.dpy, xDrawable);
430 free(pdraw);
431 return None;
432 }
433
434 /*
435 * Make sure server has the same swap interval we do for the new
436 * drawable.
437 */
438 if (psc->vtable.setSwapInterval)
439 psc->vtable.setSwapInterval(&pdraw->base, pdraw->swap_interval);
440
441 return &pdraw->base;
442 }
443
444 static int
dri2DrawableGetMSC(struct glx_screen * psc,__GLXDRIdrawable * pdraw,int64_t * ust,int64_t * msc,int64_t * sbc)445 dri2DrawableGetMSC(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
446 int64_t *ust, int64_t *msc, int64_t *sbc)
447 {
448 xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
449 xcb_dri2_get_msc_cookie_t get_msc_cookie;
450 xcb_dri2_get_msc_reply_t *get_msc_reply;
451
452 get_msc_cookie = xcb_dri2_get_msc_unchecked(c, pdraw->xDrawable);
453 get_msc_reply = xcb_dri2_get_msc_reply(c, get_msc_cookie, NULL);
454
455 if (!get_msc_reply)
456 return 0;
457
458 *ust = merge_counter(get_msc_reply->ust_hi, get_msc_reply->ust_lo);
459 *msc = merge_counter(get_msc_reply->msc_hi, get_msc_reply->msc_lo);
460 *sbc = merge_counter(get_msc_reply->sbc_hi, get_msc_reply->sbc_lo);
461 free(get_msc_reply);
462
463 return 1;
464 }
465
466 static int
dri2WaitForMSC(__GLXDRIdrawable * pdraw,int64_t target_msc,int64_t divisor,int64_t remainder,int64_t * ust,int64_t * msc,int64_t * sbc)467 dri2WaitForMSC(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
468 int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc)
469 {
470 xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
471 xcb_dri2_wait_msc_cookie_t wait_msc_cookie;
472 xcb_dri2_wait_msc_reply_t *wait_msc_reply;
473 uint32_t target_msc_hi, target_msc_lo;
474 uint32_t divisor_hi, divisor_lo;
475 uint32_t remainder_hi, remainder_lo;
476
477 split_counter(target_msc, &target_msc_hi, &target_msc_lo);
478 split_counter(divisor, &divisor_hi, &divisor_lo);
479 split_counter(remainder, &remainder_hi, &remainder_lo);
480
481 wait_msc_cookie = xcb_dri2_wait_msc_unchecked(c, pdraw->xDrawable,
482 target_msc_hi, target_msc_lo,
483 divisor_hi, divisor_lo,
484 remainder_hi, remainder_lo);
485 wait_msc_reply = xcb_dri2_wait_msc_reply(c, wait_msc_cookie, NULL);
486
487 if (!wait_msc_reply)
488 return 0;
489
490 *ust = merge_counter(wait_msc_reply->ust_hi, wait_msc_reply->ust_lo);
491 *msc = merge_counter(wait_msc_reply->msc_hi, wait_msc_reply->msc_lo);
492 *sbc = merge_counter(wait_msc_reply->sbc_hi, wait_msc_reply->sbc_lo);
493 free(wait_msc_reply);
494
495 return 1;
496 }
497
498 static int
dri2WaitForSBC(__GLXDRIdrawable * pdraw,int64_t target_sbc,int64_t * ust,int64_t * msc,int64_t * sbc)499 dri2WaitForSBC(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
500 int64_t *msc, int64_t *sbc)
501 {
502 xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
503 xcb_dri2_wait_sbc_cookie_t wait_sbc_cookie;
504 xcb_dri2_wait_sbc_reply_t *wait_sbc_reply;
505 uint32_t target_sbc_hi, target_sbc_lo;
506
507 split_counter(target_sbc, &target_sbc_hi, &target_sbc_lo);
508
509 wait_sbc_cookie = xcb_dri2_wait_sbc_unchecked(c, pdraw->xDrawable,
510 target_sbc_hi, target_sbc_lo);
511 wait_sbc_reply = xcb_dri2_wait_sbc_reply(c, wait_sbc_cookie, NULL);
512
513 if (!wait_sbc_reply)
514 return 0;
515
516 *ust = merge_counter(wait_sbc_reply->ust_hi, wait_sbc_reply->ust_lo);
517 *msc = merge_counter(wait_sbc_reply->msc_hi, wait_sbc_reply->msc_lo);
518 *sbc = merge_counter(wait_sbc_reply->sbc_hi, wait_sbc_reply->sbc_lo);
519 free(wait_sbc_reply);
520
521 return 1;
522 }
523
524 static __DRIcontext *
dri2GetCurrentContext()525 dri2GetCurrentContext()
526 {
527 struct glx_context *gc = __glXGetCurrentContext();
528 struct dri2_context *dri2Ctx = (struct dri2_context *)gc;
529
530 return (gc != &dummyContext) ? dri2Ctx->driContext : NULL;
531 }
532
533 /**
534 * dri2Throttle - Request driver throttling
535 *
536 * This function uses the DRI2 throttle extension to give the
537 * driver the opportunity to throttle on flush front, copysubbuffer
538 * and swapbuffers.
539 */
540 static void
dri2Throttle(struct dri2_screen * psc,struct dri2_drawable * draw,enum __DRI2throttleReason reason)541 dri2Throttle(struct dri2_screen *psc,
542 struct dri2_drawable *draw,
543 enum __DRI2throttleReason reason)
544 {
545 if (psc->throttle) {
546 __DRIcontext *ctx = dri2GetCurrentContext();
547
548 psc->throttle->throttle(ctx, draw->driDrawable, reason);
549 }
550 }
551
552 /**
553 * Asks the driver to flush any queued work necessary for serializing with the
554 * X command stream, and optionally the slightly more strict requirement of
555 * glFlush() equivalence (which would require flushing even if nothing had
556 * been drawn to a window system framebuffer, for example).
557 */
558 static void
dri2Flush(struct dri2_screen * psc,__DRIcontext * ctx,struct dri2_drawable * draw,unsigned flags,enum __DRI2throttleReason throttle_reason)559 dri2Flush(struct dri2_screen *psc,
560 __DRIcontext *ctx,
561 struct dri2_drawable *draw,
562 unsigned flags,
563 enum __DRI2throttleReason throttle_reason)
564 {
565 if (ctx && psc->f && psc->f->base.version >= 4) {
566 psc->f->flush_with_flags(ctx, draw->driDrawable, flags, throttle_reason);
567 } else {
568 if (flags & __DRI2_FLUSH_CONTEXT)
569 glFlush();
570
571 if (psc->f)
572 psc->f->flush(draw->driDrawable);
573
574 dri2Throttle(psc, draw, throttle_reason);
575 }
576 }
577
578 static void
__dri2CopySubBuffer(__GLXDRIdrawable * pdraw,int x,int y,int width,int height,enum __DRI2throttleReason reason,Bool flush)579 __dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y,
580 int width, int height,
581 enum __DRI2throttleReason reason, Bool flush)
582 {
583 struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
584 struct dri2_screen *psc = (struct dri2_screen *) pdraw->psc;
585 XRectangle xrect;
586 XserverRegion region;
587 __DRIcontext *ctx = dri2GetCurrentContext();
588 unsigned flags;
589
590 /* Check we have the right attachments */
591 if (!priv->have_back)
592 return;
593
594 xrect.x = x;
595 xrect.y = priv->height - y - height;
596 xrect.width = width;
597 xrect.height = height;
598
599 flags = __DRI2_FLUSH_DRAWABLE;
600 if (flush)
601 flags |= __DRI2_FLUSH_CONTEXT;
602 dri2Flush(psc, ctx, priv, flags, __DRI2_THROTTLE_COPYSUBBUFFER);
603
604 region = XFixesCreateRegion(psc->base.dpy, &xrect, 1);
605 DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region,
606 DRI2BufferFrontLeft, DRI2BufferBackLeft);
607
608 /* Refresh the fake front (if present) after we just damaged the real
609 * front.
610 */
611 if (priv->have_fake_front)
612 DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region,
613 DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
614
615 XFixesDestroyRegion(psc->base.dpy, region);
616 }
617
618 static void
dri2CopySubBuffer(__GLXDRIdrawable * pdraw,int x,int y,int width,int height,Bool flush)619 dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y,
620 int width, int height, Bool flush)
621 {
622 __dri2CopySubBuffer(pdraw, x, y, width, height,
623 __DRI2_THROTTLE_COPYSUBBUFFER, flush);
624 }
625
626
627 static void
dri2_copy_drawable(struct dri2_drawable * priv,int dest,int src)628 dri2_copy_drawable(struct dri2_drawable *priv, int dest, int src)
629 {
630 XRectangle xrect;
631 XserverRegion region;
632 struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
633
634 xrect.x = 0;
635 xrect.y = 0;
636 xrect.width = priv->width;
637 xrect.height = priv->height;
638
639 if (psc->f)
640 (*psc->f->flush) (priv->driDrawable);
641
642 region = XFixesCreateRegion(psc->base.dpy, &xrect, 1);
643 DRI2CopyRegion(psc->base.dpy, priv->base.xDrawable, region, dest, src);
644 XFixesDestroyRegion(psc->base.dpy, region);
645
646 }
647
648 static void
dri2_wait_x(struct glx_context * gc)649 dri2_wait_x(struct glx_context *gc)
650 {
651 struct dri2_drawable *priv = (struct dri2_drawable *)
652 GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
653
654 if (priv == NULL || !priv->have_fake_front)
655 return;
656
657 dri2_copy_drawable(priv, DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
658 }
659
660 static void
dri2_wait_gl(struct glx_context * gc)661 dri2_wait_gl(struct glx_context *gc)
662 {
663 struct dri2_drawable *priv = (struct dri2_drawable *)
664 GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
665
666 if (priv == NULL || !priv->have_fake_front)
667 return;
668
669 dri2_copy_drawable(priv, DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
670 }
671
672 /**
673 * Called by the driver when it needs to update the real front buffer with the
674 * contents of its fake front buffer.
675 */
676 static void
dri2FlushFrontBuffer(__DRIdrawable * driDrawable,void * loaderPrivate)677 dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate)
678 {
679 struct glx_display *priv;
680 struct dri2_display *pdp;
681 struct glx_context *gc;
682 struct dri2_drawable *pdraw = loaderPrivate;
683 struct dri2_screen *psc;
684
685 if (!pdraw)
686 return;
687
688 if (!pdraw->base.psc)
689 return;
690
691 psc = (struct dri2_screen *) pdraw->base.psc;
692
693 priv = __glXInitialize(psc->base.dpy);
694
695 if (priv == NULL)
696 return;
697
698 pdp = (struct dri2_display *) priv->dri2Display;
699 gc = __glXGetCurrentContext();
700
701 dri2Throttle(psc, pdraw, __DRI2_THROTTLE_FLUSHFRONT);
702
703 /* Old servers don't send invalidate events */
704 if (!pdp->invalidateAvailable)
705 dri2InvalidateBuffers(priv->dpy, pdraw->base.xDrawable);
706
707 dri2_wait_gl(gc);
708 }
709
710
711 static void
dri2DestroyScreen(struct glx_screen * base)712 dri2DestroyScreen(struct glx_screen *base)
713 {
714 struct dri2_screen *psc = (struct dri2_screen *) base;
715
716 /* Free the direct rendering per screen data */
717 (*psc->core->destroyScreen) (psc->driScreen);
718 driDestroyConfigs(psc->driver_configs);
719 close(psc->fd);
720 free(psc);
721 }
722
723 /**
724 * Process list of buffer received from the server
725 *
726 * Processes the list of buffers received in a reply from the server to either
727 * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
728 */
729 static void
process_buffers(struct dri2_drawable * pdraw,DRI2Buffer * buffers,unsigned count)730 process_buffers(struct dri2_drawable * pdraw, DRI2Buffer * buffers,
731 unsigned count)
732 {
733 int i;
734
735 pdraw->bufferCount = count;
736 pdraw->have_fake_front = 0;
737 pdraw->have_back = 0;
738
739 /* This assumes the DRI2 buffer attachment tokens matches the
740 * __DRIbuffer tokens. */
741 for (i = 0; i < count; i++) {
742 pdraw->buffers[i].attachment = buffers[i].attachment;
743 pdraw->buffers[i].name = buffers[i].name;
744 pdraw->buffers[i].pitch = buffers[i].pitch;
745 pdraw->buffers[i].cpp = buffers[i].cpp;
746 pdraw->buffers[i].flags = buffers[i].flags;
747 if (pdraw->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
748 pdraw->have_fake_front = 1;
749 if (pdraw->buffers[i].attachment == __DRI_BUFFER_BACK_LEFT)
750 pdraw->have_back = 1;
751 }
752
753 }
754
dri2GetSwapEventType(Display * dpy,XID drawable)755 unsigned dri2GetSwapEventType(Display* dpy, XID drawable)
756 {
757 struct glx_display *glx_dpy = __glXInitialize(dpy);
758 __GLXDRIdrawable *pdraw;
759 pdraw = dri2GetGlxDrawableFromXDrawableId(dpy, drawable);
760 if (!pdraw || !(pdraw->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
761 return 0;
762 return glx_dpy->codes->first_event + GLX_BufferSwapComplete;
763 }
764
show_fps(struct dri2_drawable * draw)765 static void show_fps(struct dri2_drawable *draw)
766 {
767 const int interval =
768 ((struct dri2_screen *) draw->base.psc)->show_fps_interval;
769 struct timeval tv;
770 uint64_t current_time;
771
772 gettimeofday(&tv, 0);
773 current_time = (uint64_t)tv.tv_sec*1000000 + (uint64_t)tv.tv_usec;
774
775 draw->frames++;
776
777 if (draw->previous_time + interval * 1000000 <= current_time) {
778 if (draw->previous_time) {
779 fprintf(stderr, "libGL: FPS = %.2f\n",
780 ((uint64_t)draw->frames * 1000000) /
781 (double)(current_time - draw->previous_time));
782 }
783 draw->frames = 0;
784 draw->previous_time = current_time;
785 }
786 }
787
788 static int64_t
dri2XcbSwapBuffers(Display * dpy,__GLXDRIdrawable * pdraw,int64_t target_msc,int64_t divisor,int64_t remainder)789 dri2XcbSwapBuffers(Display *dpy,
790 __GLXDRIdrawable *pdraw,
791 int64_t target_msc,
792 int64_t divisor,
793 int64_t remainder)
794 {
795 xcb_dri2_swap_buffers_cookie_t swap_buffers_cookie;
796 xcb_dri2_swap_buffers_reply_t *swap_buffers_reply;
797 uint32_t target_msc_hi, target_msc_lo;
798 uint32_t divisor_hi, divisor_lo;
799 uint32_t remainder_hi, remainder_lo;
800 int64_t ret = 0;
801 xcb_connection_t *c = XGetXCBConnection(dpy);
802
803 split_counter(target_msc, &target_msc_hi, &target_msc_lo);
804 split_counter(divisor, &divisor_hi, &divisor_lo);
805 split_counter(remainder, &remainder_hi, &remainder_lo);
806
807 swap_buffers_cookie =
808 xcb_dri2_swap_buffers_unchecked(c, pdraw->xDrawable,
809 target_msc_hi, target_msc_lo,
810 divisor_hi, divisor_lo,
811 remainder_hi, remainder_lo);
812
813 /* Immediately wait on the swapbuffers reply. If we didn't, we'd have
814 * to do so some time before reusing a (non-pageflipped) backbuffer.
815 * Otherwise, the new rendering could get ahead of the X Server's
816 * dispatch of the swapbuffer and you'd display garbage.
817 *
818 * We use XSync() first to reap the invalidate events through the event
819 * filter, to ensure that the next drawing doesn't use an invalidated
820 * buffer.
821 */
822 XSync(dpy, False);
823
824 swap_buffers_reply =
825 xcb_dri2_swap_buffers_reply(c, swap_buffers_cookie, NULL);
826 if (swap_buffers_reply) {
827 ret = merge_counter(swap_buffers_reply->swap_hi,
828 swap_buffers_reply->swap_lo);
829 free(swap_buffers_reply);
830 }
831 return ret;
832 }
833
834 static int64_t
dri2SwapBuffers(__GLXDRIdrawable * pdraw,int64_t target_msc,int64_t divisor,int64_t remainder,Bool flush)835 dri2SwapBuffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
836 int64_t remainder, Bool flush)
837 {
838 struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
839 struct glx_display *dpyPriv = __glXInitialize(priv->base.psc->dpy);
840 struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
841 struct dri2_display *pdp =
842 (struct dri2_display *)dpyPriv->dri2Display;
843 int64_t ret = 0;
844
845 /* Check we have the right attachments */
846 if (!priv->have_back)
847 return ret;
848
849 /* Old servers can't handle swapbuffers */
850 if (!pdp->swapAvailable) {
851 __dri2CopySubBuffer(pdraw, 0, 0, priv->width, priv->height,
852 __DRI2_THROTTLE_SWAPBUFFER, flush);
853 } else {
854 __DRIcontext *ctx = dri2GetCurrentContext();
855 unsigned flags = __DRI2_FLUSH_DRAWABLE;
856 if (flush)
857 flags |= __DRI2_FLUSH_CONTEXT;
858 dri2Flush(psc, ctx, priv, flags, __DRI2_THROTTLE_SWAPBUFFER);
859
860 ret = dri2XcbSwapBuffers(pdraw->psc->dpy, pdraw,
861 target_msc, divisor, remainder);
862 }
863
864 if (psc->show_fps_interval) {
865 show_fps(priv);
866 }
867
868 /* Old servers don't send invalidate events */
869 if (!pdp->invalidateAvailable)
870 dri2InvalidateBuffers(dpyPriv->dpy, pdraw->xDrawable);
871
872 return ret;
873 }
874
875 static __DRIbuffer *
dri2GetBuffers(__DRIdrawable * driDrawable,int * width,int * height,unsigned int * attachments,int count,int * out_count,void * loaderPrivate)876 dri2GetBuffers(__DRIdrawable * driDrawable,
877 int *width, int *height,
878 unsigned int *attachments, int count,
879 int *out_count, void *loaderPrivate)
880 {
881 struct dri2_drawable *pdraw = loaderPrivate;
882 DRI2Buffer *buffers;
883
884 buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable,
885 width, height, attachments, count, out_count);
886 if (buffers == NULL)
887 return NULL;
888
889 pdraw->width = *width;
890 pdraw->height = *height;
891 process_buffers(pdraw, buffers, *out_count);
892
893 free(buffers);
894
895 return pdraw->buffers;
896 }
897
898 static __DRIbuffer *
dri2GetBuffersWithFormat(__DRIdrawable * driDrawable,int * width,int * height,unsigned int * attachments,int count,int * out_count,void * loaderPrivate)899 dri2GetBuffersWithFormat(__DRIdrawable * driDrawable,
900 int *width, int *height,
901 unsigned int *attachments, int count,
902 int *out_count, void *loaderPrivate)
903 {
904 struct dri2_drawable *pdraw = loaderPrivate;
905 DRI2Buffer *buffers;
906
907 buffers = DRI2GetBuffersWithFormat(pdraw->base.psc->dpy,
908 pdraw->base.xDrawable,
909 width, height, attachments,
910 count, out_count);
911 if (buffers == NULL)
912 return NULL;
913
914 pdraw->width = *width;
915 pdraw->height = *height;
916 process_buffers(pdraw, buffers, *out_count);
917
918 free(buffers);
919
920 return pdraw->buffers;
921 }
922
923 static int
dri2SetSwapInterval(__GLXDRIdrawable * pdraw,int interval)924 dri2SetSwapInterval(__GLXDRIdrawable *pdraw, int interval)
925 {
926 xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy);
927 struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
928 GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
929 struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
930
931 if (psc->config)
932 psc->config->configQueryi(psc->driScreen,
933 "vblank_mode", &vblank_mode);
934
935 switch (vblank_mode) {
936 case DRI_CONF_VBLANK_NEVER:
937 if (interval != 0)
938 return GLX_BAD_VALUE;
939 break;
940 case DRI_CONF_VBLANK_ALWAYS_SYNC:
941 if (interval <= 0)
942 return GLX_BAD_VALUE;
943 break;
944 default:
945 break;
946 }
947
948 xcb_dri2_swap_interval(c, priv->base.xDrawable, interval);
949 priv->swap_interval = interval;
950
951 return 0;
952 }
953
954 static int
dri2GetSwapInterval(__GLXDRIdrawable * pdraw)955 dri2GetSwapInterval(__GLXDRIdrawable *pdraw)
956 {
957 struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
958
959 return priv->swap_interval;
960 }
961
962 static void
driSetBackgroundContext(void * loaderPrivate)963 driSetBackgroundContext(void *loaderPrivate)
964 {
965 struct dri2_context *pcp = (struct dri2_context *) loaderPrivate;
966 __glXSetCurrentContext(&pcp->base);
967 }
968
969 static GLboolean
driIsThreadSafe(void * loaderPrivate)970 driIsThreadSafe(void *loaderPrivate)
971 {
972 struct dri2_context *pcp = (struct dri2_context *) loaderPrivate;
973 /* Check Xlib is running in thread safe mode
974 *
975 * 'lock_fns' is the XLockDisplay function pointer of the X11 display 'dpy'.
976 * It wll be NULL if XInitThreads wasn't called.
977 */
978 return pcp->base.psc->dpy->lock_fns != NULL;
979 }
980
981 static const __DRIdri2LoaderExtension dri2LoaderExtension = {
982 .base = { __DRI_DRI2_LOADER, 3 },
983
984 .getBuffers = dri2GetBuffers,
985 .flushFrontBuffer = dri2FlushFrontBuffer,
986 .getBuffersWithFormat = dri2GetBuffersWithFormat,
987 };
988
989 static const __DRIdri2LoaderExtension dri2LoaderExtension_old = {
990 .base = { __DRI_DRI2_LOADER, 3 },
991
992 .getBuffers = dri2GetBuffers,
993 .flushFrontBuffer = dri2FlushFrontBuffer,
994 .getBuffersWithFormat = NULL,
995 };
996
997 static const __DRIuseInvalidateExtension dri2UseInvalidate = {
998 .base = { __DRI_USE_INVALIDATE, 1 }
999 };
1000
1001 static const __DRIbackgroundCallableExtension driBackgroundCallable = {
1002 .base = { __DRI_BACKGROUND_CALLABLE, 2 },
1003
1004 .setBackgroundContext = driSetBackgroundContext,
1005 .isThreadSafe = driIsThreadSafe,
1006 };
1007
1008 _X_HIDDEN void
dri2InvalidateBuffers(Display * dpy,XID drawable)1009 dri2InvalidateBuffers(Display *dpy, XID drawable)
1010 {
1011 __GLXDRIdrawable *pdraw =
1012 dri2GetGlxDrawableFromXDrawableId(dpy, drawable);
1013 struct dri2_screen *psc;
1014 struct dri2_drawable *pdp = (struct dri2_drawable *) pdraw;
1015
1016 if (!pdraw)
1017 return;
1018
1019 psc = (struct dri2_screen *) pdraw->psc;
1020
1021 if (psc->f && psc->f->base.version >= 3 && psc->f->invalidate)
1022 psc->f->invalidate(pdp->driDrawable);
1023 }
1024
1025 static void
dri2_bind_tex_image(Display * dpy,GLXDrawable drawable,int buffer,const int * attrib_list)1026 dri2_bind_tex_image(Display * dpy,
1027 GLXDrawable drawable,
1028 int buffer, const int *attrib_list)
1029 {
1030 struct glx_context *gc = __glXGetCurrentContext();
1031 struct dri2_context *pcp = (struct dri2_context *) gc;
1032 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
1033 struct glx_display *dpyPriv = __glXInitialize(dpy);
1034 struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
1035 struct dri2_display *pdp;
1036 struct dri2_screen *psc;
1037
1038 if (dpyPriv == NULL)
1039 return;
1040
1041 pdp = (struct dri2_display *) dpyPriv->dri2Display;
1042
1043 if (pdraw != NULL) {
1044 psc = (struct dri2_screen *) base->psc;
1045
1046 if (!pdp->invalidateAvailable && psc->f &&
1047 psc->f->base.version >= 3 && psc->f->invalidate)
1048 psc->f->invalidate(pdraw->driDrawable);
1049
1050 if (psc->texBuffer->base.version >= 2 &&
1051 psc->texBuffer->setTexBuffer2 != NULL) {
1052 (*psc->texBuffer->setTexBuffer2) (pcp->driContext,
1053 pdraw->base.textureTarget,
1054 pdraw->base.textureFormat,
1055 pdraw->driDrawable);
1056 }
1057 else {
1058 (*psc->texBuffer->setTexBuffer) (pcp->driContext,
1059 pdraw->base.textureTarget,
1060 pdraw->driDrawable);
1061 }
1062 }
1063 }
1064
1065 static void
dri2_release_tex_image(Display * dpy,GLXDrawable drawable,int buffer)1066 dri2_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
1067 {
1068 struct glx_context *gc = __glXGetCurrentContext();
1069 struct dri2_context *pcp = (struct dri2_context *) gc;
1070 __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
1071 struct glx_display *dpyPriv = __glXInitialize(dpy);
1072 struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
1073 struct dri2_screen *psc;
1074
1075 if (dpyPriv != NULL && pdraw != NULL) {
1076 psc = (struct dri2_screen *) base->psc;
1077
1078 if (psc->texBuffer->base.version >= 3 &&
1079 psc->texBuffer->releaseTexBuffer != NULL) {
1080 (*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
1081 pdraw->base.textureTarget,
1082 pdraw->driDrawable);
1083 }
1084 }
1085 }
1086
1087 static const struct glx_context_vtable dri2_context_vtable = {
1088 .destroy = dri2_destroy_context,
1089 .bind = dri2_bind_context,
1090 .unbind = dri2_unbind_context,
1091 .wait_gl = dri2_wait_gl,
1092 .wait_x = dri2_wait_x,
1093 .use_x_font = DRI_glXUseXFont,
1094 .bind_tex_image = dri2_bind_tex_image,
1095 .release_tex_image = dri2_release_tex_image,
1096 .get_proc_address = NULL,
1097 .interop_query_device_info = dri2_interop_query_device_info,
1098 .interop_export_object = dri2_interop_export_object
1099 };
1100
1101 static void
dri2BindExtensions(struct dri2_screen * psc,struct glx_display * priv,const char * driverName)1102 dri2BindExtensions(struct dri2_screen *psc, struct glx_display * priv,
1103 const char *driverName)
1104 {
1105 const struct dri2_display *const pdp = (struct dri2_display *)
1106 priv->dri2Display;
1107 const __DRIextension **extensions;
1108 int i;
1109
1110 extensions = psc->core->getExtensions(psc->driScreen);
1111
1112 __glXEnableDirectExtension(&psc->base, "GLX_SGI_swap_control");
1113 __glXEnableDirectExtension(&psc->base, "GLX_MESA_swap_control");
1114 __glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read");
1115
1116 /*
1117 * GLX_INTEL_swap_event is broken on the server side, where it's
1118 * currently unconditionally enabled. This completely breaks
1119 * systems running on drivers which don't support that extension.
1120 * There's no way to test for its presence on this side, so instead
1121 * of disabling it unconditionally, just disable it for drivers
1122 * which are known to not support it, or for DDX drivers supporting
1123 * only an older (pre-ScheduleSwap) version of DRI2.
1124 *
1125 * This is a hack which is required until:
1126 * http://lists.x.org/archives/xorg-devel/2013-February/035449.html
1127 * is merged and updated xserver makes it's way into distros:
1128 */
1129 if (pdp->swapAvailable && strcmp(driverName, "vmwgfx") != 0) {
1130 __glXEnableDirectExtension(&psc->base, "GLX_INTEL_swap_event");
1131 }
1132
1133 if (psc->dri2->base.version >= 3) {
1134 const unsigned mask = psc->dri2->getAPIMask(psc->driScreen);
1135
1136 __glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context");
1137 __glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context_profile");
1138
1139 if ((mask & ((1 << __DRI_API_GLES) |
1140 (1 << __DRI_API_GLES2) |
1141 (1 << __DRI_API_GLES3))) != 0) {
1142 __glXEnableDirectExtension(&psc->base,
1143 "GLX_EXT_create_context_es_profile");
1144 __glXEnableDirectExtension(&psc->base,
1145 "GLX_EXT_create_context_es2_profile");
1146 }
1147 }
1148
1149 for (i = 0; extensions[i]; i++) {
1150 if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) {
1151 psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
1152 __glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap");
1153 }
1154
1155 if ((strcmp(extensions[i]->name, __DRI2_FLUSH) == 0)) {
1156 psc->f = (__DRI2flushExtension *) extensions[i];
1157 /* internal driver extension, no GL extension exposed */
1158 }
1159
1160 if ((strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0))
1161 psc->config = (__DRI2configQueryExtension *) extensions[i];
1162
1163 if (((strcmp(extensions[i]->name, __DRI2_THROTTLE) == 0)))
1164 psc->throttle = (__DRI2throttleExtension *) extensions[i];
1165
1166 /* DRI2 version 3 is also required because
1167 * GLX_ARB_create_context_robustness requires GLX_ARB_create_context.
1168 */
1169 if (psc->dri2->base.version >= 3
1170 && strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0)
1171 __glXEnableDirectExtension(&psc->base,
1172 "GLX_ARB_create_context_robustness");
1173
1174 /* DRI2 version 3 is also required because
1175 * GLX_ARB_create_context_no_error requires GLX_ARB_create_context.
1176 */
1177 if (psc->dri2->base.version >= 3
1178 && strcmp(extensions[i]->name, __DRI2_NO_ERROR) == 0)
1179 __glXEnableDirectExtension(&psc->base,
1180 "GLX_ARB_create_context_no_error");
1181
1182 /* DRI2 version 3 is also required because GLX_MESA_query_renderer
1183 * requires GLX_ARB_create_context_profile.
1184 */
1185 if (psc->dri2->base.version >= 3
1186 && strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) {
1187 psc->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i];
1188 __glXEnableDirectExtension(&psc->base, "GLX_MESA_query_renderer");
1189 }
1190
1191 if (strcmp(extensions[i]->name, __DRI2_INTEROP) == 0)
1192 psc->interop = (__DRI2interopExtension*)extensions[i];
1193
1194 /* DRI2 version 3 is also required because
1195 * GLX_ARB_control_flush_control requires GLX_ARB_create_context.
1196 */
1197 if (psc->dri2->base.version >= 3
1198 && strcmp(extensions[i]->name, __DRI2_FLUSH_CONTROL) == 0)
1199 __glXEnableDirectExtension(&psc->base,
1200 "GLX_ARB_context_flush_control");
1201 }
1202 }
1203
1204 static const struct glx_screen_vtable dri2_screen_vtable = {
1205 .create_context = dri2_create_context,
1206 .create_context_attribs = dri2_create_context_attribs,
1207 .query_renderer_integer = dri2_query_renderer_integer,
1208 .query_renderer_string = dri2_query_renderer_string,
1209 };
1210
1211 static struct glx_screen *
dri2CreateScreen(int screen,struct glx_display * priv)1212 dri2CreateScreen(int screen, struct glx_display * priv)
1213 {
1214 const __DRIconfig **driver_configs;
1215 const __DRIextension **extensions;
1216 const struct dri2_display *const pdp = (struct dri2_display *)
1217 priv->dri2Display;
1218 struct dri2_screen *psc;
1219 __GLXDRIscreen *psp;
1220 struct glx_config *configs = NULL, *visuals = NULL;
1221 char *driverName = NULL, *loader_driverName, *deviceName, *tmp;
1222 drm_magic_t magic;
1223 int i;
1224 unsigned char disable;
1225
1226 psc = calloc(1, sizeof *psc);
1227 if (psc == NULL)
1228 return NULL;
1229
1230 psc->fd = -1;
1231
1232 if (!glx_screen_init(&psc->base, screen, priv)) {
1233 free(psc);
1234 return NULL;
1235 }
1236
1237 if (!DRI2Connect(priv->dpy, RootWindow(priv->dpy, screen),
1238 &driverName, &deviceName)) {
1239 glx_screen_cleanup(&psc->base);
1240 free(psc);
1241 InfoMessageF("screen %d does not appear to be DRI2 capable\n", screen);
1242 return NULL;
1243 }
1244
1245 psc->fd = loader_open_device(deviceName);
1246 if (psc->fd < 0) {
1247 ErrorMessageF("failed to open %s: %s\n", deviceName, strerror(errno));
1248 goto handle_error;
1249 }
1250
1251 if (drmGetMagic(psc->fd, &magic)) {
1252 ErrorMessageF("failed to get magic\n");
1253 goto handle_error;
1254 }
1255
1256 if (!DRI2Authenticate(priv->dpy, RootWindow(priv->dpy, screen), magic)) {
1257 ErrorMessageF("failed to authenticate magic %d\n", magic);
1258 goto handle_error;
1259 }
1260
1261 /* If Mesa knows about the appropriate driver for this fd, then trust it.
1262 * Otherwise, default to the server's value.
1263 */
1264 loader_driverName = loader_get_driver_for_fd(psc->fd);
1265 if (loader_driverName) {
1266 free(driverName);
1267 driverName = loader_driverName;
1268 }
1269
1270 extensions = driOpenDriver(driverName, &psc->driver);
1271 if (extensions == NULL)
1272 goto handle_error;
1273
1274 for (i = 0; extensions[i]; i++) {
1275 if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
1276 psc->core = (__DRIcoreExtension *) extensions[i];
1277 if (strcmp(extensions[i]->name, __DRI_DRI2) == 0)
1278 psc->dri2 = (__DRIdri2Extension *) extensions[i];
1279 }
1280
1281 if (psc->core == NULL || psc->dri2 == NULL) {
1282 ErrorMessageF("core dri or dri2 extension not found\n");
1283 goto handle_error;
1284 }
1285
1286 if (psc->dri2->base.version >= 4) {
1287 psc->driScreen =
1288 psc->dri2->createNewScreen2(screen, psc->fd,
1289 (const __DRIextension **)
1290 &pdp->loader_extensions[0],
1291 extensions,
1292 &driver_configs, psc);
1293 } else {
1294 psc->driScreen =
1295 psc->dri2->createNewScreen(screen, psc->fd,
1296 (const __DRIextension **)
1297 &pdp->loader_extensions[0],
1298 &driver_configs, psc);
1299 }
1300
1301 if (psc->driScreen == NULL) {
1302 ErrorMessageF("failed to create dri screen\n");
1303 goto handle_error;
1304 }
1305
1306 dri2BindExtensions(psc, priv, driverName);
1307
1308 configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs);
1309 visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
1310
1311 if (!configs || !visuals) {
1312 ErrorMessageF("No matching fbConfigs or visuals found\n");
1313 goto handle_error;
1314 }
1315
1316 glx_config_destroy_list(psc->base.configs);
1317 psc->base.configs = configs;
1318 glx_config_destroy_list(psc->base.visuals);
1319 psc->base.visuals = visuals;
1320
1321 psc->driver_configs = driver_configs;
1322
1323 psc->base.vtable = &dri2_screen_vtable;
1324 psp = &psc->vtable;
1325 psc->base.driScreen = psp;
1326 psp->destroyScreen = dri2DestroyScreen;
1327 psp->createDrawable = dri2CreateDrawable;
1328 psp->swapBuffers = dri2SwapBuffers;
1329 psp->getDrawableMSC = NULL;
1330 psp->waitForMSC = NULL;
1331 psp->waitForSBC = NULL;
1332 psp->setSwapInterval = NULL;
1333 psp->getSwapInterval = NULL;
1334 psp->getBufferAge = NULL;
1335
1336 if (pdp->driMinor >= 2) {
1337 psp->getDrawableMSC = dri2DrawableGetMSC;
1338 psp->waitForMSC = dri2WaitForMSC;
1339 psp->waitForSBC = dri2WaitForSBC;
1340 psp->setSwapInterval = dri2SetSwapInterval;
1341 psp->getSwapInterval = dri2GetSwapInterval;
1342 if (psc->config->configQueryb(psc->driScreen,
1343 "glx_disable_oml_sync_control",
1344 &disable) || !disable)
1345 __glXEnableDirectExtension(&psc->base, "GLX_OML_sync_control");
1346 }
1347
1348 if (psc->config->configQueryb(psc->driScreen,
1349 "glx_disable_sgi_video_sync",
1350 &disable) || !disable)
1351 __glXEnableDirectExtension(&psc->base, "GLX_SGI_video_sync");
1352
1353 /* DRI2 supports SubBuffer through DRI2CopyRegion, so it's always
1354 * available.*/
1355 psp->copySubBuffer = dri2CopySubBuffer;
1356 __glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
1357
1358 free(driverName);
1359 free(deviceName);
1360
1361 tmp = getenv("LIBGL_SHOW_FPS");
1362 psc->show_fps_interval = (tmp) ? atoi(tmp) : 0;
1363 if (psc->show_fps_interval < 0)
1364 psc->show_fps_interval = 0;
1365
1366 InfoMessageF("Using DRI2 for screen %d\n", screen);
1367
1368 return &psc->base;
1369
1370 handle_error:
1371 CriticalErrorMessageF("failed to load driver: %s\n", driverName);
1372
1373 if (configs)
1374 glx_config_destroy_list(configs);
1375 if (visuals)
1376 glx_config_destroy_list(visuals);
1377 if (psc->driScreen)
1378 psc->core->destroyScreen(psc->driScreen);
1379 psc->driScreen = NULL;
1380 if (psc->fd >= 0)
1381 close(psc->fd);
1382 if (psc->driver)
1383 dlclose(psc->driver);
1384
1385 free(driverName);
1386 free(deviceName);
1387 glx_screen_cleanup(&psc->base);
1388 free(psc);
1389
1390 return NULL;
1391 }
1392
1393 /* Called from __glXFreeDisplayPrivate.
1394 */
1395 static void
dri2DestroyDisplay(__GLXDRIdisplay * dpy)1396 dri2DestroyDisplay(__GLXDRIdisplay * dpy)
1397 {
1398 struct dri2_display *pdp = (struct dri2_display *) dpy;
1399
1400 __glxHashDestroy(pdp->dri2Hash);
1401 free(dpy);
1402 }
1403
1404 _X_HIDDEN __GLXDRIdrawable *
dri2GetGlxDrawableFromXDrawableId(Display * dpy,XID id)1405 dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id)
1406 {
1407 struct glx_display *d = __glXInitialize(dpy);
1408 struct dri2_display *pdp = (struct dri2_display *) d->dri2Display;
1409 __GLXDRIdrawable *pdraw;
1410
1411 if (__glxHashLookup(pdp->dri2Hash, id, (void *) &pdraw) == 0)
1412 return pdraw;
1413
1414 return NULL;
1415 }
1416
1417 /*
1418 * Allocate, initialize and return a __DRIdisplayPrivate object.
1419 * This is called from __glXInitialize() when we are given a new
1420 * display pointer.
1421 */
1422 _X_HIDDEN __GLXDRIdisplay *
dri2CreateDisplay(Display * dpy)1423 dri2CreateDisplay(Display * dpy)
1424 {
1425 struct dri2_display *pdp;
1426 int eventBase, errorBase, i;
1427
1428 if (!DRI2QueryExtension(dpy, &eventBase, &errorBase))
1429 return NULL;
1430
1431 pdp = malloc(sizeof *pdp);
1432 if (pdp == NULL)
1433 return NULL;
1434
1435 if (!DRI2QueryVersion(dpy, &pdp->driMajor, &pdp->driMinor)) {
1436 free(pdp);
1437 return NULL;
1438 }
1439
1440 pdp->driPatch = 0;
1441 pdp->swapAvailable = (pdp->driMinor >= 2);
1442 pdp->invalidateAvailable = (pdp->driMinor >= 3);
1443
1444 pdp->base.destroyDisplay = dri2DestroyDisplay;
1445 pdp->base.createScreen = dri2CreateScreen;
1446
1447 i = 0;
1448 if (pdp->driMinor < 1)
1449 pdp->loader_extensions[i++] = &dri2LoaderExtension_old.base;
1450 else
1451 pdp->loader_extensions[i++] = &dri2LoaderExtension.base;
1452
1453 pdp->loader_extensions[i++] = &dri2UseInvalidate.base;
1454
1455 pdp->loader_extensions[i++] = &driBackgroundCallable.base;
1456
1457 pdp->loader_extensions[i++] = NULL;
1458
1459 pdp->dri2Hash = __glxHashCreate();
1460 if (pdp->dri2Hash == NULL) {
1461 free(pdp);
1462 return NULL;
1463 }
1464
1465 return &pdp->base;
1466 }
1467
1468 #endif /* GLX_DIRECT_RENDERING */
1469