• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2013 Keith Packard
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that copyright
7  * notice and this permission notice appear in supporting documentation, and
8  * that the name of the copyright holders not be used in advertising or
9  * publicity pertaining to distribution of the software without specific,
10  * written prior permission.  The copyright holders make no representations
11  * about the suitability of this software for any purpose.  It is provided "as
12  * is" without express or implied warranty.
13  *
14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20  * OF THIS SOFTWARE.
21  */
22 
23 /*
24  * Portions of this code were adapted from dri2_glx.c which carries the
25  * following copyright:
26  *
27  * Copyright © 2008 Red Hat, Inc.
28  *
29  * Permission is hereby granted, free of charge, to any person obtaining a
30  * copy of this software and associated documentation files (the "Soft-
31  * ware"), to deal in the Software without restriction, including without
32  * limitation the rights to use, copy, modify, merge, publish, distribute,
33  * and/or sell copies of the Software, and to permit persons to whom the
34  * Software is furnished to do so, provided that the above copyright
35  * notice(s) and this permission notice appear in all copies of the Soft-
36  * ware and that both the above copyright notice(s) and this permission
37  * notice appear in supporting documentation.
38  *
39  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
40  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
41  * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
42  * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
43  * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
44  * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
45  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
46  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
47  * MANCE OF THIS SOFTWARE.
48  *
49  * Except as contained in this notice, the name of a copyright holder shall
50  * not be used in advertising or otherwise to promote the sale, use or
51  * other dealings in this Software without prior written authorization of
52  * the copyright holder.
53  *
54  * Authors:
55  *   Kristian Høgsberg (krh@redhat.com)
56  */
57 
58 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
59 
60 #include <X11/Xlib.h>
61 #include <X11/extensions/Xfixes.h>
62 #include <X11/Xlib-xcb.h>
63 #include <X11/xshmfence.h>
64 #include <xcb/xcb.h>
65 #include <xcb/dri3.h>
66 #include <xcb/present.h>
67 #include <GL/gl.h>
68 #include "glxclient.h"
69 #include <dlfcn.h>
70 #include <fcntl.h>
71 #include <unistd.h>
72 #include <sys/types.h>
73 #include <sys/mman.h>
74 #include <sys/time.h>
75 
76 #include "dri_common.h"
77 #include "dri3_priv.h"
78 #include "loader.h"
79 #include "dri2.h"
80 
81 static struct dri3_drawable *
loader_drawable_to_dri3_drawable(struct loader_dri3_drawable * draw)82 loader_drawable_to_dri3_drawable(struct loader_dri3_drawable *draw) {
83    size_t offset = offsetof(struct dri3_drawable, loader_drawable);
84    if (!draw)
85       return NULL;
86    return (struct dri3_drawable *)(((void*) draw) - offset);
87 }
88 
89 static void
glx_dri3_set_drawable_size(struct loader_dri3_drawable * draw,int width,int height)90 glx_dri3_set_drawable_size(struct loader_dri3_drawable *draw,
91                            int width, int height)
92 {
93    /* Nothing to do */
94 }
95 
96 static bool
glx_dri3_in_current_context(struct loader_dri3_drawable * draw)97 glx_dri3_in_current_context(struct loader_dri3_drawable *draw)
98 {
99    struct dri3_drawable *priv = loader_drawable_to_dri3_drawable(draw);
100 
101    if (!priv)
102       return false;
103 
104    struct dri3_context *pcp = (struct dri3_context *) __glXGetCurrentContext();
105    struct dri3_screen *psc = (struct dri3_screen *) priv->base.psc;
106 
107    return (&pcp->base != &dummyContext) && pcp->base.psc == &psc->base;
108 }
109 
110 static __DRIcontext *
glx_dri3_get_dri_context(struct loader_dri3_drawable * draw)111 glx_dri3_get_dri_context(struct loader_dri3_drawable *draw)
112 {
113    struct glx_context *gc = __glXGetCurrentContext();
114    struct dri3_context *dri3Ctx = (struct dri3_context *) gc;
115 
116    return (gc != &dummyContext) ? dri3Ctx->driContext : NULL;
117 }
118 
119 static __DRIscreen *
glx_dri3_get_dri_screen(void)120 glx_dri3_get_dri_screen(void)
121 {
122    struct glx_context *gc = __glXGetCurrentContext();
123    struct dri3_context *pcp = (struct dri3_context *) gc;
124    struct dri3_screen *psc = (struct dri3_screen *) pcp->base.psc;
125 
126    return (gc != &dummyContext && psc) ? psc->driScreen : NULL;
127 }
128 
129 static void
glx_dri3_flush_drawable(struct loader_dri3_drawable * draw,unsigned flags)130 glx_dri3_flush_drawable(struct loader_dri3_drawable *draw, unsigned flags)
131 {
132    loader_dri3_flush(draw, flags, __DRI2_THROTTLE_SWAPBUFFER);
133 }
134 
135 static void
glx_dri3_show_fps(struct loader_dri3_drawable * draw,uint64_t current_ust)136 glx_dri3_show_fps(struct loader_dri3_drawable *draw, uint64_t current_ust)
137 {
138    struct dri3_drawable *priv = loader_drawable_to_dri3_drawable(draw);
139    const uint64_t interval =
140       ((struct dri3_screen *) priv->base.psc)->show_fps_interval;
141 
142    if (!interval)
143       return;
144 
145    priv->frames++;
146 
147    /* DRI3+Present together uses microseconds for UST. */
148    if (priv->previous_ust + interval * 1000000 <= current_ust) {
149       if (priv->previous_ust) {
150          fprintf(stderr, "libGL: FPS = %.1f\n",
151                  ((uint64_t) priv->frames * 1000000) /
152                  (double)(current_ust - priv->previous_ust));
153       }
154       priv->frames = 0;
155       priv->previous_ust = current_ust;
156    }
157 }
158 
159 static const struct loader_dri3_vtable glx_dri3_vtable = {
160    .set_drawable_size = glx_dri3_set_drawable_size,
161    .in_current_context = glx_dri3_in_current_context,
162    .get_dri_context = glx_dri3_get_dri_context,
163    .get_dri_screen = glx_dri3_get_dri_screen,
164    .flush_drawable = glx_dri3_flush_drawable,
165    .show_fps = glx_dri3_show_fps,
166 };
167 
168 
169 static const struct glx_context_vtable dri3_context_vtable;
170 
171 static void
dri3_destroy_context(struct glx_context * context)172 dri3_destroy_context(struct glx_context *context)
173 {
174    struct dri3_context *pcp = (struct dri3_context *) context;
175    struct dri3_screen *psc = (struct dri3_screen *) context->psc;
176 
177    driReleaseDrawables(&pcp->base);
178 
179    free((char *) context->extensions);
180 
181    (*psc->core->destroyContext) (pcp->driContext);
182 
183    free(pcp);
184 }
185 
186 static Bool
dri3_bind_context(struct glx_context * context,struct glx_context * old,GLXDrawable draw,GLXDrawable read)187 dri3_bind_context(struct glx_context *context, struct glx_context *old,
188                   GLXDrawable draw, GLXDrawable read)
189 {
190    struct dri3_context *pcp = (struct dri3_context *) context;
191    struct dri3_screen *psc = (struct dri3_screen *) pcp->base.psc;
192    struct dri3_drawable *pdraw, *pread;
193    __DRIdrawable *dri_draw = NULL, *dri_read = NULL;
194 
195    pdraw = (struct dri3_drawable *) driFetchDrawable(context, draw);
196    pread = (struct dri3_drawable *) driFetchDrawable(context, read);
197 
198    driReleaseDrawables(&pcp->base);
199 
200    if (pdraw)
201       dri_draw = pdraw->loader_drawable.dri_drawable;
202    else if (draw != None)
203       return GLXBadDrawable;
204 
205    if (pread)
206       dri_read = pread->loader_drawable.dri_drawable;
207    else if (read != None)
208       return GLXBadDrawable;
209 
210    if (!(*psc->core->bindContext) (pcp->driContext, dri_draw, dri_read))
211       return GLXBadContext;
212 
213    if (dri_draw)
214       (*psc->f->invalidate)(dri_draw);
215    if (dri_read && dri_read != dri_draw)
216       (*psc->f->invalidate)(dri_read);
217 
218    return Success;
219 }
220 
221 static void
dri3_unbind_context(struct glx_context * context,struct glx_context * new)222 dri3_unbind_context(struct glx_context *context, struct glx_context *new)
223 {
224    struct dri3_context *pcp = (struct dri3_context *) context;
225    struct dri3_screen *psc = (struct dri3_screen *) pcp->base.psc;
226 
227    (*psc->core->unbindContext) (pcp->driContext);
228 }
229 
230 static struct glx_context *
dri3_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 dri3_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 dri3_context *pcp = NULL;
239    struct dri3_context *pcp_shared = NULL;
240    struct dri3_screen *psc = (struct dri3_screen *) base;
241    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
242    __DRIcontext *shared = NULL;
243 
244    uint32_t minor_ver = 1;
245    uint32_t major_ver = 2;
246    uint32_t flags = 0;
247    unsigned api;
248    int reset = __DRI_CTX_RESET_NO_NOTIFICATION;
249    int release = __DRI_CTX_RELEASE_BEHAVIOR_FLUSH;
250    uint32_t ctx_attribs[2 * 6];
251    unsigned num_ctx_attribs = 0;
252    uint32_t render_type;
253 
254    /* Remap the GLX tokens to DRI2 tokens.
255     */
256    if (!dri2_convert_glx_attribs(num_attribs, attribs,
257                                  &major_ver, &minor_ver,
258                                  &render_type, &flags, &api,
259                                  &reset, &release, error))
260       goto error_exit;
261 
262    /* Check the renderType value */
263    if (!validate_renderType_against_config(config_base, render_type))
264        goto error_exit;
265 
266    if (shareList) {
267       pcp_shared = (struct dri3_context *) shareList;
268       shared = pcp_shared->driContext;
269    }
270 
271    pcp = calloc(1, sizeof *pcp);
272    if (pcp == NULL) {
273       *error = __DRI_CTX_ERROR_NO_MEMORY;
274       goto error_exit;
275    }
276 
277    if (!glx_context_init(&pcp->base, &psc->base, config_base))
278       goto error_exit;
279 
280    ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION;
281    ctx_attribs[num_ctx_attribs++] = major_ver;
282    ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION;
283    ctx_attribs[num_ctx_attribs++] = minor_ver;
284 
285    /* Only send a value when the non-default value is requested.  By doing
286     * this we don't have to check the driver's DRI3 version before sending the
287     * default value.
288     */
289    if (reset != __DRI_CTX_RESET_NO_NOTIFICATION) {
290       ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RESET_STRATEGY;
291       ctx_attribs[num_ctx_attribs++] = reset;
292    }
293 
294    if (release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH) {
295       ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR;
296       ctx_attribs[num_ctx_attribs++] = release;
297    }
298 
299    if (flags != 0) {
300       ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS;
301 
302       /* The current __DRI_CTX_FLAG_* values are identical to the
303        * GLX_CONTEXT_*_BIT values.
304        */
305       ctx_attribs[num_ctx_attribs++] = flags;
306    }
307 
308    pcp->driContext =
309       (*psc->image_driver->createContextAttribs) (psc->driScreen,
310                                                   api,
311                                                   config ? config->driConfig
312                                                          : NULL,
313                                                   shared,
314                                                   num_ctx_attribs / 2,
315                                                   ctx_attribs,
316                                                   error,
317                                                   pcp);
318 
319    if (pcp->driContext == NULL)
320       goto error_exit;
321 
322    pcp->base.vtable = &dri3_context_vtable;
323 
324    return &pcp->base;
325 
326 error_exit:
327    free(pcp);
328 
329    return NULL;
330 }
331 
332 static struct glx_context *
dri3_create_context(struct glx_screen * base,struct glx_config * config_base,struct glx_context * shareList,int renderType)333 dri3_create_context(struct glx_screen *base,
334                     struct glx_config *config_base,
335                     struct glx_context *shareList, int renderType)
336 {
337    unsigned int error;
338    uint32_t attribs[2] = { GLX_RENDER_TYPE, renderType };
339 
340    return dri3_create_context_attribs(base, config_base, shareList,
341                                       1, attribs, &error);
342 }
343 
344 static void
dri3_destroy_drawable(__GLXDRIdrawable * base)345 dri3_destroy_drawable(__GLXDRIdrawable *base)
346 {
347    struct dri3_drawable *pdraw = (struct dri3_drawable *) base;
348 
349    loader_dri3_drawable_fini(&pdraw->loader_drawable);
350 
351    free(pdraw);
352 }
353 
354 static __GLXDRIdrawable *
dri3_create_drawable(struct glx_screen * base,XID xDrawable,GLXDrawable drawable,struct glx_config * config_base)355 dri3_create_drawable(struct glx_screen *base, XID xDrawable,
356                      GLXDrawable drawable, struct glx_config *config_base)
357 {
358    struct dri3_drawable *pdraw;
359    struct dri3_screen *psc = (struct dri3_screen *) base;
360    __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
361 
362    pdraw = calloc(1, sizeof(*pdraw));
363    if (!pdraw)
364       return NULL;
365 
366    pdraw->base.destroyDrawable = dri3_destroy_drawable;
367    pdraw->base.xDrawable = xDrawable;
368    pdraw->base.drawable = drawable;
369    pdraw->base.psc = &psc->base;
370 
371    (void) __glXInitialize(psc->base.dpy);
372 
373    if (loader_dri3_drawable_init(XGetXCBConnection(base->dpy),
374                                  xDrawable, psc->driScreen,
375                                  psc->is_different_gpu, config->driConfig,
376                                  &psc->loader_dri3_ext, &glx_dri3_vtable,
377                                  &pdraw->loader_drawable)) {
378       free(pdraw);
379       return NULL;
380    }
381 
382    return &pdraw->base;
383 }
384 
385 /** dri3_wait_for_msc
386  *
387  * Get the X server to send an event when the target msc/divisor/remainder is
388  * reached.
389  */
390 static int
dri3_wait_for_msc(__GLXDRIdrawable * pdraw,int64_t target_msc,int64_t divisor,int64_t remainder,int64_t * ust,int64_t * msc,int64_t * sbc)391 dri3_wait_for_msc(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
392                   int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc)
393 {
394    struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
395 
396    loader_dri3_wait_for_msc(&priv->loader_drawable, target_msc, divisor,
397                             remainder, ust, msc, sbc);
398 
399    return 1;
400 }
401 
402 /** dri3_drawable_get_msc
403  *
404  * Return the current UST/MSC/SBC triplet by asking the server
405  * for an event
406  */
407 static int
dri3_drawable_get_msc(struct glx_screen * psc,__GLXDRIdrawable * pdraw,int64_t * ust,int64_t * msc,int64_t * sbc)408 dri3_drawable_get_msc(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
409                       int64_t *ust, int64_t *msc, int64_t *sbc)
410 {
411    return dri3_wait_for_msc(pdraw, 0, 0, 0, ust, msc,sbc);
412 }
413 
414 /** dri3_wait_for_sbc
415  *
416  * Wait for the completed swap buffer count to reach the specified
417  * target. Presumably the application knows that this will be reached with
418  * outstanding complete events, or we're going to be here awhile.
419  */
420 static int
dri3_wait_for_sbc(__GLXDRIdrawable * pdraw,int64_t target_sbc,int64_t * ust,int64_t * msc,int64_t * sbc)421 dri3_wait_for_sbc(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
422                   int64_t *msc, int64_t *sbc)
423 {
424    struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
425 
426    return loader_dri3_wait_for_sbc(&priv->loader_drawable, target_sbc,
427                                    ust, msc, sbc);
428 }
429 
430 static void
dri3_copy_sub_buffer(__GLXDRIdrawable * pdraw,int x,int y,int width,int height,Bool flush)431 dri3_copy_sub_buffer(__GLXDRIdrawable *pdraw, int x, int y,
432                      int width, int height,
433                      Bool flush)
434 {
435    struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
436 
437    loader_dri3_copy_sub_buffer(&priv->loader_drawable, x, y,
438                                width, height, flush);
439 }
440 
441 static void
dri3_wait_x(struct glx_context * gc)442 dri3_wait_x(struct glx_context *gc)
443 {
444    struct dri3_drawable *priv = (struct dri3_drawable *)
445       GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
446 
447    if (priv)
448       loader_dri3_wait_x(&priv->loader_drawable);
449 }
450 
451 static void
dri3_wait_gl(struct glx_context * gc)452 dri3_wait_gl(struct glx_context *gc)
453 {
454    struct dri3_drawable *priv = (struct dri3_drawable *)
455       GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
456 
457    if (priv)
458       loader_dri3_wait_gl(&priv->loader_drawable);
459 }
460 
461 /**
462  * Called by the driver when it needs to update the real front buffer with the
463  * contents of its fake front buffer.
464  */
465 static void
dri3_flush_front_buffer(__DRIdrawable * driDrawable,void * loaderPrivate)466 dri3_flush_front_buffer(__DRIdrawable *driDrawable, void *loaderPrivate)
467 {
468    struct loader_dri3_drawable *draw = loaderPrivate;
469    struct dri3_drawable *pdraw = loader_drawable_to_dri3_drawable(draw);
470    struct dri3_screen *psc;
471 
472    if (!pdraw)
473       return;
474 
475    if (!pdraw->base.psc)
476       return;
477 
478    psc = (struct dri3_screen *) pdraw->base.psc;
479 
480    (void) __glXInitialize(psc->base.dpy);
481 
482    loader_dri3_flush(draw, __DRI2_FLUSH_DRAWABLE, __DRI2_THROTTLE_FLUSHFRONT);
483 
484    (*psc->f->invalidate)(driDrawable);
485    loader_dri3_wait_gl(draw);
486 }
487 
488 /**
489  * Make sure all pending swapbuffers have been submitted to hardware
490  *
491  * \param driDrawable[in]  Pointer to the dri drawable whose swaps we are
492  * flushing.
493  * \param loaderPrivate[in]  Pointer to the corresponding struct
494  * loader_dri_drawable.
495  */
496 static void
dri3_flush_swap_buffers(__DRIdrawable * driDrawable,void * loaderPrivate)497 dri3_flush_swap_buffers(__DRIdrawable *driDrawable, void *loaderPrivate)
498 {
499    struct loader_dri3_drawable *draw = loaderPrivate;
500    struct dri3_drawable *pdraw = loader_drawable_to_dri3_drawable(draw);
501    struct dri3_screen *psc;
502 
503    if (!pdraw)
504       return;
505 
506    if (!pdraw->base.psc)
507       return;
508 
509    psc = (struct dri3_screen *) pdraw->base.psc;
510 
511    (void) __glXInitialize(psc->base.dpy);
512    loader_dri3_swapbuffer_barrier(draw);
513 }
514 
515 static void
dri_set_background_context(void * loaderPrivate)516 dri_set_background_context(void *loaderPrivate)
517 {
518    struct dri3_context *pcp = (struct dri3_context *)loaderPrivate;
519    __glXSetCurrentContext(&pcp->base);
520 }
521 
522 static GLboolean
dri_is_thread_safe(void * loaderPrivate)523 dri_is_thread_safe(void *loaderPrivate)
524 {
525    /* Unlike DRI2, DRI3 doesn't call GetBuffers/GetBuffersWithFormat
526     * during draw so we're safe here.
527     */
528    return true;
529 }
530 
531 /* The image loader extension record for DRI3
532  */
533 static const __DRIimageLoaderExtension imageLoaderExtension = {
534    .base = { __DRI_IMAGE_LOADER, 3 },
535 
536    .getBuffers          = loader_dri3_get_buffers,
537    .flushFrontBuffer    = dri3_flush_front_buffer,
538    .flushSwapBuffers    = dri3_flush_swap_buffers,
539 };
540 
541 const __DRIuseInvalidateExtension dri3UseInvalidate = {
542    .base = { __DRI_USE_INVALIDATE, 1 }
543 };
544 
545 static const __DRIbackgroundCallableExtension driBackgroundCallable = {
546    .base = { __DRI_BACKGROUND_CALLABLE, 2 },
547 
548    .setBackgroundContext = dri_set_background_context,
549    .isThreadSafe         = dri_is_thread_safe,
550 };
551 
552 static const __DRIextension *loader_extensions[] = {
553    &imageLoaderExtension.base,
554    &dri3UseInvalidate.base,
555    &driBackgroundCallable.base,
556    NULL
557 };
558 
559 /** dri3_swap_buffers
560  *
561  * Make the current back buffer visible using the present extension
562  */
563 static int64_t
dri3_swap_buffers(__GLXDRIdrawable * pdraw,int64_t target_msc,int64_t divisor,int64_t remainder,Bool flush)564 dri3_swap_buffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
565                   int64_t remainder, Bool flush)
566 {
567    struct dri3_drawable *priv = (struct dri3_drawable *) pdraw;
568    unsigned flags = __DRI2_FLUSH_DRAWABLE;
569 
570    if (flush)
571       flags |= __DRI2_FLUSH_CONTEXT;
572 
573    return loader_dri3_swap_buffers_msc(&priv->loader_drawable,
574                                        target_msc, divisor, remainder,
575                                        flags, false);
576 }
577 
578 static int
dri3_get_buffer_age(__GLXDRIdrawable * pdraw)579 dri3_get_buffer_age(__GLXDRIdrawable *pdraw)
580 {
581    struct dri3_drawable *priv = (struct dri3_drawable *)pdraw;
582 
583    return loader_dri3_query_buffer_age(&priv->loader_drawable);
584 }
585 
586 /** dri3_destroy_screen
587  */
588 static void
dri3_destroy_screen(struct glx_screen * base)589 dri3_destroy_screen(struct glx_screen *base)
590 {
591    struct dri3_screen *psc = (struct dri3_screen *) base;
592 
593    /* Free the direct rendering per screen data */
594    loader_dri3_close_screen(psc->driScreen);
595    (*psc->core->destroyScreen) (psc->driScreen);
596    driDestroyConfigs(psc->driver_configs);
597    close(psc->fd);
598    free(psc);
599 }
600 
601 /** dri3_set_swap_interval
602  *
603  * Record the application swap interval specification,
604  */
605 static int
dri3_set_swap_interval(__GLXDRIdrawable * pdraw,int interval)606 dri3_set_swap_interval(__GLXDRIdrawable *pdraw, int interval)
607 {
608    assert(pdraw != NULL);
609 
610    struct dri3_drawable *priv =  (struct dri3_drawable *) pdraw;
611    GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
612    struct dri3_screen *psc = (struct dri3_screen *) priv->base.psc;
613 
614    if (psc->config)
615       psc->config->configQueryi(psc->driScreen,
616                                 "vblank_mode", &vblank_mode);
617 
618    switch (vblank_mode) {
619    case DRI_CONF_VBLANK_NEVER:
620       if (interval != 0)
621          return GLX_BAD_VALUE;
622       break;
623    case DRI_CONF_VBLANK_ALWAYS_SYNC:
624       if (interval <= 0)
625          return GLX_BAD_VALUE;
626       break;
627    default:
628       break;
629    }
630 
631    priv->swap_interval = interval;
632    loader_dri3_set_swap_interval(&priv->loader_drawable, interval);
633 
634    return 0;
635 }
636 
637 /** dri3_get_swap_interval
638  *
639  * Return the stored swap interval
640  */
641 static int
dri3_get_swap_interval(__GLXDRIdrawable * pdraw)642 dri3_get_swap_interval(__GLXDRIdrawable *pdraw)
643 {
644    assert(pdraw != NULL);
645 
646    struct dri3_drawable *priv =  (struct dri3_drawable *) pdraw;
647 
648   return priv->swap_interval;
649 }
650 
651 static void
dri3_bind_tex_image(Display * dpy,GLXDrawable drawable,int buffer,const int * attrib_list)652 dri3_bind_tex_image(Display * dpy,
653                     GLXDrawable drawable,
654                     int buffer, const int *attrib_list)
655 {
656    struct glx_context *gc = __glXGetCurrentContext();
657    struct dri3_context *pcp = (struct dri3_context *) gc;
658    __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
659    struct dri3_drawable *pdraw = (struct dri3_drawable *) base;
660    struct dri3_screen *psc;
661 
662    if (pdraw != NULL) {
663       psc = (struct dri3_screen *) base->psc;
664 
665       (*psc->f->invalidate)(pdraw->loader_drawable.dri_drawable);
666 
667       XSync(dpy, false);
668 
669       (*psc->texBuffer->setTexBuffer2) (pcp->driContext,
670                                         pdraw->base.textureTarget,
671                                         pdraw->base.textureFormat,
672                                         pdraw->loader_drawable.dri_drawable);
673    }
674 }
675 
676 static void
dri3_release_tex_image(Display * dpy,GLXDrawable drawable,int buffer)677 dri3_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
678 {
679    struct glx_context *gc = __glXGetCurrentContext();
680    struct dri3_context *pcp = (struct dri3_context *) gc;
681    __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
682    struct dri3_drawable *pdraw = (struct dri3_drawable *) base;
683    struct dri3_screen *psc;
684 
685    if (pdraw != NULL) {
686       psc = (struct dri3_screen *) base->psc;
687 
688       if (psc->texBuffer->base.version >= 3 &&
689           psc->texBuffer->releaseTexBuffer != NULL)
690          (*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
691                                               pdraw->base.textureTarget,
692                                               pdraw->loader_drawable.dri_drawable);
693    }
694 }
695 
696 static const struct glx_context_vtable dri3_context_vtable = {
697    .destroy             = dri3_destroy_context,
698    .bind                = dri3_bind_context,
699    .unbind              = dri3_unbind_context,
700    .wait_gl             = dri3_wait_gl,
701    .wait_x              = dri3_wait_x,
702    .use_x_font          = DRI_glXUseXFont,
703    .bind_tex_image      = dri3_bind_tex_image,
704    .release_tex_image   = dri3_release_tex_image,
705    .get_proc_address    = NULL,
706    .interop_query_device_info = dri3_interop_query_device_info,
707    .interop_export_object = dri3_interop_export_object
708 };
709 
710 /** dri3_bind_extensions
711  *
712  * Enable all of the extensions supported on DRI3
713  */
714 static void
dri3_bind_extensions(struct dri3_screen * psc,struct glx_display * priv,const char * driverName)715 dri3_bind_extensions(struct dri3_screen *psc, struct glx_display * priv,
716                      const char *driverName)
717 {
718    const __DRIextension **extensions;
719    unsigned mask;
720    int i;
721 
722    extensions = psc->core->getExtensions(psc->driScreen);
723 
724    __glXEnableDirectExtension(&psc->base, "GLX_SGI_video_sync");
725    __glXEnableDirectExtension(&psc->base, "GLX_SGI_swap_control");
726    __glXEnableDirectExtension(&psc->base, "GLX_MESA_swap_control");
727    __glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read");
728    __glXEnableDirectExtension(&psc->base, "GLX_INTEL_swap_event");
729 
730    mask = psc->image_driver->getAPIMask(psc->driScreen);
731 
732    __glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context");
733    __glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context_profile");
734 
735    if ((mask & ((1 << __DRI_API_GLES) |
736                 (1 << __DRI_API_GLES2) |
737                 (1 << __DRI_API_GLES3))) != 0) {
738       __glXEnableDirectExtension(&psc->base,
739                                  "GLX_EXT_create_context_es_profile");
740       __glXEnableDirectExtension(&psc->base,
741                                  "GLX_EXT_create_context_es2_profile");
742    }
743 
744    for (i = 0; extensions[i]; i++) {
745       /* when on a different gpu than the server, the server pixmaps
746        * can have a tiling mode we can't read. Thus we can't create
747        * a texture from them.
748        */
749       if (!psc->is_different_gpu &&
750          (strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) {
751          psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
752          __glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap");
753       }
754 
755       if ((strcmp(extensions[i]->name, __DRI2_FLUSH) == 0)) {
756          psc->f = (__DRI2flushExtension *) extensions[i];
757          /* internal driver extension, no GL extension exposed */
758       }
759 
760       if (strcmp(extensions[i]->name, __DRI_IMAGE) == 0)
761          psc->image = (__DRIimageExtension *) extensions[i];
762 
763       if ((strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0))
764          psc->config = (__DRI2configQueryExtension *) extensions[i];
765 
766       if (strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0)
767          __glXEnableDirectExtension(&psc->base,
768                                     "GLX_ARB_create_context_robustness");
769 
770       if (strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) {
771          psc->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i];
772          __glXEnableDirectExtension(&psc->base, "GLX_MESA_query_renderer");
773       }
774 
775       if (strcmp(extensions[i]->name, __DRI2_INTEROP) == 0)
776 	 psc->interop = (__DRI2interopExtension*)extensions[i];
777 
778       if (strcmp(extensions[i]->name, __DRI2_FLUSH_CONTROL) == 0)
779          __glXEnableDirectExtension(&psc->base,
780                                     "GLX_ARB_context_flush_control");
781    }
782 }
783 
784 static const struct glx_screen_vtable dri3_screen_vtable = {
785    .create_context         = dri3_create_context,
786    .create_context_attribs = dri3_create_context_attribs,
787    .query_renderer_integer = dri3_query_renderer_integer,
788    .query_renderer_string  = dri3_query_renderer_string,
789 };
790 
791 /** dri3_create_screen
792  *
793  * Initialize DRI3 on the specified screen.
794  *
795  * Opens the DRI device, locates the appropriate DRI driver
796  * and loads that.
797  *
798  * Checks to see if the driver supports the necessary extensions
799  *
800  * Initializes the driver for the screen and sets up our structures
801  */
802 
803 static struct glx_screen *
dri3_create_screen(int screen,struct glx_display * priv)804 dri3_create_screen(int screen, struct glx_display * priv)
805 {
806    xcb_connection_t *c = XGetXCBConnection(priv->dpy);
807    const __DRIconfig **driver_configs;
808    const __DRIextension **extensions;
809    const struct dri3_display *const pdp = (struct dri3_display *)
810       priv->dri3Display;
811    struct dri3_screen *psc;
812    __GLXDRIscreen *psp;
813    struct glx_config *configs = NULL, *visuals = NULL;
814    char *driverName, *tmp;
815    int i;
816    unsigned char disable;
817 
818    psc = calloc(1, sizeof *psc);
819    if (psc == NULL)
820       return NULL;
821 
822    psc->fd = -1;
823 
824    if (!glx_screen_init(&psc->base, screen, priv)) {
825       free(psc);
826       return NULL;
827    }
828 
829    psc->fd = loader_dri3_open(c, RootWindow(priv->dpy, screen), None);
830    if (psc->fd < 0) {
831       int conn_error = xcb_connection_has_error(c);
832 
833       glx_screen_cleanup(&psc->base);
834       free(psc);
835       InfoMessageF("screen %d does not appear to be DRI3 capable\n", screen);
836 
837       if (conn_error)
838          ErrorMessageF("Connection closed during DRI3 initialization failure");
839 
840       return NULL;
841    }
842 
843    psc->fd = loader_get_user_preferred_fd(psc->fd, &psc->is_different_gpu);
844 
845    driverName = loader_get_driver_for_fd(psc->fd);
846    if (!driverName) {
847       ErrorMessageF("No driver found\n");
848       goto handle_error;
849    }
850 
851    psc->driver = driOpenDriver(driverName);
852    if (psc->driver == NULL) {
853       ErrorMessageF("driver pointer missing\n");
854       goto handle_error;
855    }
856 
857    extensions = driGetDriverExtensions(psc->driver, driverName);
858    if (extensions == NULL)
859       goto handle_error;
860 
861    for (i = 0; extensions[i]; i++) {
862       if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
863          psc->core = (__DRIcoreExtension *) extensions[i];
864       if (strcmp(extensions[i]->name, __DRI_IMAGE_DRIVER) == 0)
865          psc->image_driver = (__DRIimageDriverExtension *) extensions[i];
866    }
867 
868 
869    if (psc->core == NULL) {
870       ErrorMessageF("core dri driver extension not found\n");
871       goto handle_error;
872    }
873 
874    if (psc->image_driver == NULL) {
875       ErrorMessageF("image driver extension not found\n");
876       goto handle_error;
877    }
878 
879    psc->driScreen =
880       psc->image_driver->createNewScreen2(screen, psc->fd,
881                                           pdp->loader_extensions,
882                                           extensions,
883                                           &driver_configs, psc);
884 
885    if (psc->driScreen == NULL) {
886       ErrorMessageF("failed to create dri screen\n");
887       goto handle_error;
888    }
889 
890    dri3_bind_extensions(psc, priv, driverName);
891 
892    if (!psc->image || psc->image->base.version < 7 || !psc->image->createImageFromFds) {
893       ErrorMessageF("Version 7 or imageFromFds image extension not found\n");
894       goto handle_error;
895    }
896 
897    if (!psc->f || psc->f->base.version < 4) {
898       ErrorMessageF("Version 4 or later of flush extension not found\n");
899       goto handle_error;
900    }
901 
902    if (psc->is_different_gpu && psc->image->base.version < 9) {
903       ErrorMessageF("Different GPU, but image extension version 9 or later not found\n");
904       goto handle_error;
905    }
906 
907    if (psc->is_different_gpu && !psc->image->blitImage) {
908       ErrorMessageF("Different GPU, but blitImage not implemented for this driver\n");
909       goto handle_error;
910    }
911 
912    if (!psc->is_different_gpu && (
913        !psc->texBuffer || psc->texBuffer->base.version < 2 ||
914        !psc->texBuffer->setTexBuffer2
915        )) {
916       ErrorMessageF("Version 2 or later of texBuffer extension not found\n");
917       goto handle_error;
918    }
919 
920    psc->loader_dri3_ext.core = psc->core;
921    psc->loader_dri3_ext.image_driver = psc->image_driver;
922    psc->loader_dri3_ext.flush = psc->f;
923    psc->loader_dri3_ext.tex_buffer = psc->texBuffer;
924    psc->loader_dri3_ext.image = psc->image;
925    psc->loader_dri3_ext.config = psc->config;
926 
927    configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs);
928    visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
929 
930    if (!configs || !visuals) {
931        ErrorMessageF("No matching fbConfigs or visuals found\n");
932        goto handle_error;
933    }
934 
935    glx_config_destroy_list(psc->base.configs);
936    psc->base.configs = configs;
937    glx_config_destroy_list(psc->base.visuals);
938    psc->base.visuals = visuals;
939 
940    psc->driver_configs = driver_configs;
941 
942    psc->base.vtable = &dri3_screen_vtable;
943    psp = &psc->vtable;
944    psc->base.driScreen = psp;
945    psp->destroyScreen = dri3_destroy_screen;
946    psp->createDrawable = dri3_create_drawable;
947    psp->swapBuffers = dri3_swap_buffers;
948 
949    psp->getDrawableMSC = dri3_drawable_get_msc;
950    psp->waitForMSC = dri3_wait_for_msc;
951    psp->waitForSBC = dri3_wait_for_sbc;
952    psp->setSwapInterval = dri3_set_swap_interval;
953    psp->getSwapInterval = dri3_get_swap_interval;
954    if (psc->config->configQueryb(psc->driScreen,
955                                  "glx_disable_oml_sync_control",
956                                  &disable) || !disable)
957       __glXEnableDirectExtension(&psc->base, "GLX_OML_sync_control");
958 
959    psp->copySubBuffer = dri3_copy_sub_buffer;
960    __glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
961 
962    psp->getBufferAge = dri3_get_buffer_age;
963    if (psc->config->configQueryb(psc->driScreen,
964                                  "glx_disable_ext_buffer_age",
965                                  &disable) || !disable)
966       __glXEnableDirectExtension(&psc->base, "GLX_EXT_buffer_age");
967 
968    free(driverName);
969 
970    tmp = getenv("LIBGL_SHOW_FPS");
971    psc->show_fps_interval = tmp ? atoi(tmp) : 0;
972    if (psc->show_fps_interval < 0)
973       psc->show_fps_interval = 0;
974 
975    InfoMessageF("Using DRI3 for screen %d\n", screen);
976 
977    return &psc->base;
978 
979 handle_error:
980    CriticalErrorMessageF("failed to load driver: %s\n", driverName);
981 
982    if (configs)
983        glx_config_destroy_list(configs);
984    if (visuals)
985        glx_config_destroy_list(visuals);
986    if (psc->driScreen)
987        psc->core->destroyScreen(psc->driScreen);
988    psc->driScreen = NULL;
989    if (psc->fd >= 0)
990       close(psc->fd);
991    if (psc->driver)
992       dlclose(psc->driver);
993 
994    free(driverName);
995    glx_screen_cleanup(&psc->base);
996    free(psc);
997 
998    return NULL;
999 }
1000 
1001 /** dri_destroy_display
1002  *
1003  * Called from __glXFreeDisplayPrivate.
1004  */
1005 static void
dri3_destroy_display(__GLXDRIdisplay * dpy)1006 dri3_destroy_display(__GLXDRIdisplay * dpy)
1007 {
1008    free(dpy);
1009 }
1010 
1011 /** dri3_create_display
1012  *
1013  * Allocate, initialize and return a __DRIdisplayPrivate object.
1014  * This is called from __glXInitialize() when we are given a new
1015  * display pointer. This is public to that function, but hidden from
1016  * outside of libGL.
1017  */
1018 _X_HIDDEN __GLXDRIdisplay *
dri3_create_display(Display * dpy)1019 dri3_create_display(Display * dpy)
1020 {
1021    struct dri3_display                  *pdp;
1022    xcb_connection_t                     *c = XGetXCBConnection(dpy);
1023    xcb_dri3_query_version_cookie_t      dri3_cookie;
1024    xcb_dri3_query_version_reply_t       *dri3_reply;
1025    xcb_present_query_version_cookie_t   present_cookie;
1026    xcb_present_query_version_reply_t    *present_reply;
1027    xcb_generic_error_t                  *error;
1028    const xcb_query_extension_reply_t    *extension;
1029 
1030    xcb_prefetch_extension_data(c, &xcb_dri3_id);
1031    xcb_prefetch_extension_data(c, &xcb_present_id);
1032 
1033    extension = xcb_get_extension_data(c, &xcb_dri3_id);
1034    if (!(extension && extension->present))
1035       return NULL;
1036 
1037    extension = xcb_get_extension_data(c, &xcb_present_id);
1038    if (!(extension && extension->present))
1039       return NULL;
1040 
1041    dri3_cookie = xcb_dri3_query_version(c,
1042                                         XCB_DRI3_MAJOR_VERSION,
1043                                         XCB_DRI3_MINOR_VERSION);
1044 
1045 
1046    present_cookie = xcb_present_query_version(c,
1047                                    XCB_PRESENT_MAJOR_VERSION,
1048                                    XCB_PRESENT_MINOR_VERSION);
1049 
1050    pdp = malloc(sizeof *pdp);
1051    if (pdp == NULL)
1052       return NULL;
1053 
1054    dri3_reply = xcb_dri3_query_version_reply(c, dri3_cookie, &error);
1055    if (!dri3_reply) {
1056       free(error);
1057       goto no_extension;
1058    }
1059 
1060    pdp->dri3Major = dri3_reply->major_version;
1061    pdp->dri3Minor = dri3_reply->minor_version;
1062    free(dri3_reply);
1063 
1064    present_reply = xcb_present_query_version_reply(c, present_cookie, &error);
1065    if (!present_reply) {
1066       free(error);
1067       goto no_extension;
1068    }
1069    pdp->presentMajor = present_reply->major_version;
1070    pdp->presentMinor = present_reply->minor_version;
1071    free(present_reply);
1072 
1073    pdp->base.destroyDisplay = dri3_destroy_display;
1074    pdp->base.createScreen = dri3_create_screen;
1075 
1076    loader_set_logger(dri_message);
1077 
1078    pdp->loader_extensions = loader_extensions;
1079 
1080    return &pdp->base;
1081 no_extension:
1082    free(pdp);
1083    return NULL;
1084 }
1085 
1086 #endif /* GLX_DIRECT_RENDERING */
1087