dri2_glx.c revision 3d3ecb8520ccca0863026a94e7fda9840aff6c0a 
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/extensions/Xdamage.h>
38#include "glapi.h"
39#include "glxclient.h"
40#include <X11/extensions/dri2proto.h>
41#include "xf86dri.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 "xf86drm.h"
48#include "dri2.h"
49#include "dri_common.h"
50
51/* From xmlpool/options.h, user exposed so should be stable */
52#define DRI_CONF_VBLANK_NEVER 0
53#define DRI_CONF_VBLANK_DEF_INTERVAL_0 1
54#define DRI_CONF_VBLANK_DEF_INTERVAL_1 2
55#define DRI_CONF_VBLANK_ALWAYS_SYNC 3
56
57#undef DRI2_MINOR
58#define DRI2_MINOR 1
59
60struct dri2_display
61{
62   __GLXDRIdisplay base;
63
64   /*
65    ** XFree86-DRI version information
66    */
67   int driMajor;
68   int driMinor;
69   int driPatch;
70   int swapAvailable;
71   int invalidateAvailable;
72
73   __glxHashTable *dri2Hash;
74
75   const __DRIextension *loader_extensions[4];
76};
77
78struct dri2_screen {
79   struct glx_screen base;
80
81   __DRIscreen *driScreen;
82   __GLXDRIscreen vtable;
83   const __DRIdri2Extension *dri2;
84   const __DRIcoreExtension *core;
85
86   const __DRI2flushExtension *f;
87   const __DRI2configQueryExtension *config;
88   const __DRItexBufferExtension *texBuffer;
89   const __DRIconfig **driver_configs;
90
91   void *driver;
92   int fd;
93};
94
95struct dri2_context
96{
97   struct glx_context base;
98   __DRIcontext *driContext;
99};
100
101struct dri2_drawable
102{
103   __GLXDRIdrawable base;
104   __DRIdrawable *driDrawable;
105   __DRIbuffer buffers[5];
106   int bufferCount;
107   int width, height;
108   int have_back;
109   int have_fake_front;
110   int swap_interval;
111};
112
113static const struct glx_context_vtable dri2_context_vtable;
114
115static void
116dri2_destroy_context(struct glx_context *context)
117{
118   struct dri2_context *pcp = (struct dri2_context *) context;
119   struct dri2_screen *psc = (struct dri2_screen *) context->psc;
120
121   driReleaseDrawables(&pcp->base);
122
123   if (context->xid)
124      glx_send_destroy_context(psc->base.dpy, context->xid);
125
126   if (context->extensions)
127      XFree((char *) context->extensions);
128
129   (*psc->core->destroyContext) (pcp->driContext);
130
131   Xfree(pcp);
132}
133
134static Bool
135dri2_bind_context(struct glx_context *context, struct glx_context *old,
136		  GLXDrawable draw, GLXDrawable read)
137{
138   struct dri2_context *pcp = (struct dri2_context *) context;
139   struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc;
140   struct dri2_drawable *pdraw, *pread;
141   struct dri2_display *pdp;
142
143   pdraw = (struct dri2_drawable *) driFetchDrawable(context, draw);
144   pread = (struct dri2_drawable *) driFetchDrawable(context, read);
145
146   if (pdraw == NULL || pread == NULL)
147      return GLXBadDrawable;
148
149   if (!(*psc->core->bindContext) (pcp->driContext,
150				   pdraw->driDrawable, pread->driDrawable))
151      return GLXBadContext;
152
153   /* If the server doesn't send invalidate events, we may miss a
154    * resize before the rendering starts.  Invalidate the buffers now
155    * so the driver will recheck before rendering starts. */
156   pdp = (struct dri2_display *) psc->base.display;
157   if (!pdp->invalidateAvailable) {
158      dri2InvalidateBuffers(psc->base.dpy, pdraw->base.xDrawable);
159      if (pread != pdraw)
160	 dri2InvalidateBuffers(psc->base.dpy, pread->base.xDrawable);
161   }
162
163   return Success;
164}
165
166static void
167dri2_unbind_context(struct glx_context *context, struct glx_context *new)
168{
169   struct dri2_context *pcp = (struct dri2_context *) context;
170   struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc;
171
172   (*psc->core->unbindContext) (pcp->driContext);
173
174   if (context == new)
175      driReleaseDrawables(&pcp->base);
176}
177
178static struct glx_context *
179dri2_create_context(struct glx_screen *base,
180		    struct glx_config *config_base,
181		    struct glx_context *shareList, int renderType)
182{
183   struct dri2_context *pcp, *pcp_shared;
184   struct dri2_screen *psc = (struct dri2_screen *) base;
185   __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
186   __DRIcontext *shared = NULL;
187
188   if (shareList) {
189      pcp_shared = (struct dri2_context *) shareList;
190      shared = pcp_shared->driContext;
191   }
192
193   pcp = Xmalloc(sizeof *pcp);
194   if (pcp == NULL)
195      return NULL;
196
197   memset(pcp, 0, sizeof *pcp);
198   if (!glx_context_init(&pcp->base, &psc->base, &config->base)) {
199      Xfree(pcp);
200      return NULL;
201   }
202
203   pcp->driContext =
204      (*psc->dri2->createNewContext) (psc->driScreen,
205                                      config->driConfig, shared, pcp);
206
207   if (pcp->driContext == NULL) {
208      Xfree(pcp);
209      return NULL;
210   }
211
212   pcp->base.vtable = &dri2_context_vtable;
213
214   return &pcp->base;
215}
216
217static void
218dri2DestroyDrawable(__GLXDRIdrawable *base)
219{
220   struct dri2_screen *psc = (struct dri2_screen *) base->psc;
221   struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
222   struct glx_display *dpyPriv = psc->base.display;
223   struct dri2_display *pdp = (struct dri2_display *)dpyPriv->dri2Display;
224
225   __glxHashDelete(pdp->dri2Hash, pdraw->base.xDrawable);
226   (*psc->core->destroyDrawable) (pdraw->driDrawable);
227
228   /* If it's a GLX 1.3 drawables, we can destroy the DRI2 drawable
229    * now, as the application explicitly asked to destroy the GLX
230    * drawable.  Otherwise, for legacy drawables, we let the DRI2
231    * drawable linger on the server, since there's no good way of
232    * knowing when the application is done with it.  The server will
233    * destroy the DRI2 drawable when it destroys the X drawable or the
234    * client exits anyway. */
235   if (pdraw->base.xDrawable != pdraw->base.drawable)
236      DRI2DestroyDrawable(psc->base.dpy, pdraw->base.xDrawable);
237
238   Xfree(pdraw);
239}
240
241static __GLXDRIdrawable *
242dri2CreateDrawable(struct glx_screen *base, XID xDrawable,
243		   GLXDrawable drawable, struct glx_config *config_base)
244{
245   struct dri2_drawable *pdraw;
246   struct dri2_screen *psc = (struct dri2_screen *) base;
247   __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base;
248   struct glx_display *dpyPriv;
249   struct dri2_display *pdp;
250   GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
251
252   pdraw = Xmalloc(sizeof(*pdraw));
253   if (!pdraw)
254      return NULL;
255
256   memset(pdraw, 0, sizeof *pdraw);
257   pdraw->base.destroyDrawable = dri2DestroyDrawable;
258   pdraw->base.xDrawable = xDrawable;
259   pdraw->base.drawable = drawable;
260   pdraw->base.psc = &psc->base;
261   pdraw->bufferCount = 0;
262   pdraw->swap_interval = 1; /* default may be overridden below */
263   pdraw->have_back = 0;
264
265   if (psc->config)
266      psc->config->configQueryi(psc->driScreen,
267				"vblank_mode", &vblank_mode);
268
269   switch (vblank_mode) {
270   case DRI_CONF_VBLANK_NEVER:
271   case DRI_CONF_VBLANK_DEF_INTERVAL_0:
272      pdraw->swap_interval = 0;
273      break;
274   case DRI_CONF_VBLANK_DEF_INTERVAL_1:
275   case DRI_CONF_VBLANK_ALWAYS_SYNC:
276   default:
277      pdraw->swap_interval = 1;
278      break;
279   }
280
281   DRI2CreateDrawable(psc->base.dpy, xDrawable);
282
283   dpyPriv = __glXInitialize(psc->base.dpy);
284   pdp = (struct dri2_display *)dpyPriv->dri2Display;;
285   /* Create a new drawable */
286   pdraw->driDrawable =
287      (*psc->dri2->createNewDrawable) (psc->driScreen,
288                                       config->driConfig, pdraw);
289
290   if (!pdraw->driDrawable) {
291      DRI2DestroyDrawable(psc->base.dpy, xDrawable);
292      Xfree(pdraw);
293      return NULL;
294   }
295
296   if (__glxHashInsert(pdp->dri2Hash, xDrawable, pdraw)) {
297      (*psc->core->destroyDrawable) (pdraw->driDrawable);
298      DRI2DestroyDrawable(psc->base.dpy, xDrawable);
299      Xfree(pdraw);
300      return None;
301   }
302
303
304#ifdef X_DRI2SwapInterval
305   /*
306    * Make sure server has the same swap interval we do for the new
307    * drawable.
308    */
309   if (pdp->swapAvailable)
310      DRI2SwapInterval(psc->base.dpy, xDrawable, pdraw->swap_interval);
311#endif
312
313   return &pdraw->base;
314}
315
316#ifdef X_DRI2GetMSC
317
318static int
319dri2DrawableGetMSC(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
320		   int64_t *ust, int64_t *msc, int64_t *sbc)
321{
322   CARD64 dri2_ust, dri2_msc, dri2_sbc;
323   int ret;
324
325   ret = DRI2GetMSC(psc->dpy, pdraw->xDrawable,
326		    &dri2_ust, &dri2_msc, &dri2_sbc);
327   *ust = dri2_ust;
328   *msc = dri2_msc;
329   *sbc = dri2_sbc;
330
331   return ret;
332}
333
334#endif
335
336
337#ifdef X_DRI2WaitMSC
338
339static int
340dri2WaitForMSC(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
341	       int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc)
342{
343   CARD64 dri2_ust, dri2_msc, dri2_sbc;
344   int ret;
345
346   ret = DRI2WaitMSC(pdraw->psc->dpy, pdraw->xDrawable, target_msc, divisor,
347		     remainder, &dri2_ust, &dri2_msc, &dri2_sbc);
348   *ust = dri2_ust;
349   *msc = dri2_msc;
350   *sbc = dri2_sbc;
351
352   return ret;
353}
354
355static int
356dri2WaitForSBC(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust,
357	       int64_t *msc, int64_t *sbc)
358{
359   CARD64 dri2_ust, dri2_msc, dri2_sbc;
360   int ret;
361
362   ret = DRI2WaitSBC(pdraw->psc->dpy, pdraw->xDrawable,
363		     target_sbc, &dri2_ust, &dri2_msc, &dri2_sbc);
364   *ust = dri2_ust;
365   *msc = dri2_msc;
366   *sbc = dri2_sbc;
367
368   return ret;
369}
370
371#endif /* X_DRI2WaitMSC */
372
373static void
374dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y, int width, int height)
375{
376   struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
377   struct dri2_screen *psc = (struct dri2_screen *) pdraw->psc;
378   XRectangle xrect;
379   XserverRegion region;
380
381   /* Check we have the right attachments */
382   if (!priv->have_back)
383      return;
384
385   xrect.x = x;
386   xrect.y = priv->height - y - height;
387   xrect.width = width;
388   xrect.height = height;
389
390#ifdef __DRI2_FLUSH
391   if (psc->f)
392      (*psc->f->flush) (priv->driDrawable);
393#endif
394
395   region = XFixesCreateRegion(psc->base.dpy, &xrect, 1);
396   DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region,
397                  DRI2BufferFrontLeft, DRI2BufferBackLeft);
398
399   /* Refresh the fake front (if present) after we just damaged the real
400    * front.
401    */
402   if (priv->have_fake_front)
403      DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region,
404		     DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
405
406   XFixesDestroyRegion(psc->base.dpy, region);
407}
408
409static void
410dri2_copy_drawable(struct dri2_drawable *priv, int dest, int src)
411{
412   XRectangle xrect;
413   XserverRegion region;
414   struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
415
416   xrect.x = 0;
417   xrect.y = 0;
418   xrect.width = priv->width;
419   xrect.height = priv->height;
420
421#ifdef __DRI2_FLUSH
422   if (psc->f)
423      (*psc->f->flush) (priv->driDrawable);
424#endif
425
426   region = XFixesCreateRegion(psc->base.dpy, &xrect, 1);
427   DRI2CopyRegion(psc->base.dpy, priv->base.xDrawable, region, dest, src);
428   XFixesDestroyRegion(psc->base.dpy, region);
429
430}
431
432static void
433dri2_wait_x(struct glx_context *gc)
434{
435   struct dri2_drawable *priv = (struct dri2_drawable *)
436      GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
437
438   if (priv == NULL || !priv->have_fake_front)
439      return;
440
441   dri2_copy_drawable(priv, DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft);
442}
443
444static void
445dri2_wait_gl(struct glx_context *gc)
446{
447   struct dri2_drawable *priv = (struct dri2_drawable *)
448      GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable);
449
450   if (priv == NULL || !priv->have_fake_front)
451      return;
452
453   dri2_copy_drawable(priv, DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft);
454}
455
456static void
457dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate)
458{
459   struct dri2_drawable *pdraw = loaderPrivate;
460   if (!pdraw)
461      return;
462
463   if (!pdraw->base.psc)
464      return;
465
466   struct glx_display *priv = __glXInitialize(pdraw->base.psc->dpy);
467   struct dri2_display *pdp = (struct dri2_display *)priv->dri2Display;
468   struct glx_context *gc = __glXGetCurrentContext();
469
470   /* Old servers don't send invalidate events */
471   if (!pdp->invalidateAvailable)
472       dri2InvalidateBuffers(priv->dpy, pdraw->base.xDrawable);
473
474   dri2_wait_gl(gc);
475}
476
477
478static void
479dri2DestroyScreen(struct glx_screen *base)
480{
481   struct dri2_screen *psc = (struct dri2_screen *) base;
482
483   /* Free the direct rendering per screen data */
484   (*psc->core->destroyScreen) (psc->driScreen);
485   driDestroyConfigs(psc->driver_configs);
486   close(psc->fd);
487   Xfree(psc);
488}
489
490/**
491 * Process list of buffer received from the server
492 *
493 * Processes the list of buffers received in a reply from the server to either
494 * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
495 */
496static void
497process_buffers(struct dri2_drawable * pdraw, DRI2Buffer * buffers,
498                unsigned count)
499{
500   int i;
501
502   pdraw->bufferCount = count;
503   pdraw->have_fake_front = 0;
504   pdraw->have_back = 0;
505
506   /* This assumes the DRI2 buffer attachment tokens matches the
507    * __DRIbuffer tokens. */
508   for (i = 0; i < count; i++) {
509      pdraw->buffers[i].attachment = buffers[i].attachment;
510      pdraw->buffers[i].name = buffers[i].name;
511      pdraw->buffers[i].pitch = buffers[i].pitch;
512      pdraw->buffers[i].cpp = buffers[i].cpp;
513      pdraw->buffers[i].flags = buffers[i].flags;
514      if (pdraw->buffers[i].attachment == __DRI_BUFFER_FAKE_FRONT_LEFT)
515         pdraw->have_fake_front = 1;
516      if (pdraw->buffers[i].attachment == __DRI_BUFFER_BACK_LEFT)
517         pdraw->have_back = 1;
518   }
519
520}
521
522unsigned dri2GetSwapEventType(Display* dpy, XID drawable)
523{
524      struct glx_display *glx_dpy = __glXInitialize(dpy);
525      __GLXDRIdrawable *pdraw;
526      pdraw = dri2GetGlxDrawableFromXDrawableId(dpy, drawable);
527      if (!pdraw || !(pdraw->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK))
528         return 0;
529      return glx_dpy->codes->first_event + GLX_BufferSwapComplete;
530}
531
532static int64_t
533dri2SwapBuffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor,
534		int64_t remainder)
535{
536    struct dri2_drawable *priv = (struct dri2_drawable *) pdraw;
537    struct glx_display *dpyPriv = __glXInitialize(priv->base.psc->dpy);
538    struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
539    struct dri2_display *pdp =
540	(struct dri2_display *)dpyPriv->dri2Display;
541    CARD64 ret = 0;
542
543#ifdef __DRI2_FLUSH
544    if (psc->f) {
545       struct glx_context *gc = __glXGetCurrentContext();
546
547       if (gc) {
548	  (*psc->f->flush)(priv->driDrawable);
549       }
550    }
551#endif
552
553    /* Old servers don't send invalidate events */
554    if (!pdp->invalidateAvailable)
555       dri2InvalidateBuffers(dpyPriv->dpy, pdraw->xDrawable);
556
557    /* Old servers can't handle swapbuffers */
558    if (!pdp->swapAvailable) {
559       dri2CopySubBuffer(pdraw, 0, 0, priv->width, priv->height);
560       return 0;
561    }
562
563#ifdef X_DRI2SwapBuffers
564    DRI2SwapBuffers(psc->base.dpy, pdraw->xDrawable, target_msc, divisor,
565		    remainder, &ret);
566#endif
567
568    return ret;
569}
570
571static __DRIbuffer *
572dri2GetBuffers(__DRIdrawable * driDrawable,
573               int *width, int *height,
574               unsigned int *attachments, int count,
575               int *out_count, void *loaderPrivate)
576{
577   struct dri2_drawable *pdraw = loaderPrivate;
578   DRI2Buffer *buffers;
579
580   buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable,
581                            width, height, attachments, count, out_count);
582   if (buffers == NULL)
583      return NULL;
584
585   pdraw->width = *width;
586   pdraw->height = *height;
587   process_buffers(pdraw, buffers, *out_count);
588
589   Xfree(buffers);
590
591   return pdraw->buffers;
592}
593
594static __DRIbuffer *
595dri2GetBuffersWithFormat(__DRIdrawable * driDrawable,
596                         int *width, int *height,
597                         unsigned int *attachments, int count,
598                         int *out_count, void *loaderPrivate)
599{
600   struct dri2_drawable *pdraw = loaderPrivate;
601   DRI2Buffer *buffers;
602
603   buffers = DRI2GetBuffersWithFormat(pdraw->base.psc->dpy,
604                                      pdraw->base.xDrawable,
605                                      width, height, attachments,
606                                      count, out_count);
607   if (buffers == NULL)
608      return NULL;
609
610   pdraw->width = *width;
611   pdraw->height = *height;
612   process_buffers(pdraw, buffers, *out_count);
613
614   Xfree(buffers);
615
616   return pdraw->buffers;
617}
618
619#ifdef X_DRI2SwapInterval
620
621static int
622dri2SetSwapInterval(__GLXDRIdrawable *pdraw, int interval)
623{
624   struct dri2_drawable *priv =  (struct dri2_drawable *) pdraw;
625   GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1;
626   struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc;
627
628   if (psc->config)
629      psc->config->configQueryi(psc->driScreen,
630				"vblank_mode", &vblank_mode);
631
632   switch (vblank_mode) {
633   case DRI_CONF_VBLANK_NEVER:
634      return GLX_BAD_VALUE;
635   case DRI_CONF_VBLANK_ALWAYS_SYNC:
636      if (interval <= 0)
637	 return GLX_BAD_VALUE;
638      break;
639   default:
640      break;
641   }
642
643   DRI2SwapInterval(priv->base.psc->dpy, priv->base.xDrawable, interval);
644   priv->swap_interval = interval;
645
646   return 0;
647}
648
649static int
650dri2GetSwapInterval(__GLXDRIdrawable *pdraw)
651{
652   struct dri2_drawable *priv =  (struct dri2_drawable *) pdraw;
653
654  return priv->swap_interval;
655}
656
657#endif /* X_DRI2SwapInterval */
658
659static const __DRIdri2LoaderExtension dri2LoaderExtension = {
660   {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
661   dri2GetBuffers,
662   dri2FlushFrontBuffer,
663   dri2GetBuffersWithFormat,
664};
665
666static const __DRIdri2LoaderExtension dri2LoaderExtension_old = {
667   {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION},
668   dri2GetBuffers,
669   dri2FlushFrontBuffer,
670   NULL,
671};
672
673#ifdef __DRI_USE_INVALIDATE
674static const __DRIuseInvalidateExtension dri2UseInvalidate = {
675   { __DRI_USE_INVALIDATE, __DRI_USE_INVALIDATE_VERSION }
676};
677#endif
678
679_X_HIDDEN void
680dri2InvalidateBuffers(Display *dpy, XID drawable)
681{
682   __GLXDRIdrawable *pdraw =
683      dri2GetGlxDrawableFromXDrawableId(dpy, drawable);
684   struct dri2_screen *psc;
685   struct dri2_drawable *pdp = (struct dri2_drawable *) pdraw;
686
687   if (!pdraw)
688      return;
689
690   psc = (struct dri2_screen *) pdraw->psc;
691
692#if __DRI2_FLUSH_VERSION >= 3
693   if (pdraw && psc->f && psc->f->base.version >= 3 && psc->f->invalidate)
694       psc->f->invalidate(pdp->driDrawable);
695#endif
696}
697
698static void
699dri2_bind_tex_image(Display * dpy,
700		    GLXDrawable drawable,
701		    int buffer, const int *attrib_list)
702{
703   struct glx_context *gc = __glXGetCurrentContext();
704   struct dri2_context *pcp = (struct dri2_context *) gc;
705   __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
706   struct glx_display *dpyPriv = __glXInitialize(dpy);
707   struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
708   struct dri2_display *pdp =
709      (struct dri2_display *) dpyPriv->dri2Display;
710   struct dri2_screen *psc;
711
712   if (pdraw != NULL) {
713      psc = (struct dri2_screen *) base->psc;
714
715#if __DRI2_FLUSH_VERSION >= 3
716      if (!pdp->invalidateAvailable && psc->f &&
717           psc->f->base.version >= 3 && psc->f->invalidate)
718	 psc->f->invalidate(pdraw->driDrawable);
719#endif
720
721      if (psc->texBuffer->base.version >= 2 &&
722	  psc->texBuffer->setTexBuffer2 != NULL) {
723	 (*psc->texBuffer->setTexBuffer2) (pcp->driContext,
724					   pdraw->base.textureTarget,
725					   pdraw->base.textureFormat,
726					   pdraw->driDrawable);
727      }
728      else {
729	 (*psc->texBuffer->setTexBuffer) (pcp->driContext,
730					  pdraw->base.textureTarget,
731					  pdraw->driDrawable);
732      }
733   }
734}
735
736static void
737dri2_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer)
738{
739#if __DRI_TEX_BUFFER_VERSION >= 3
740   struct glx_context *gc = __glXGetCurrentContext();
741   struct dri2_context *pcp = (struct dri2_context *) gc;
742   __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable);
743   struct glx_display *dpyPriv = __glXInitialize(dpy);
744   struct dri2_drawable *pdraw = (struct dri2_drawable *) base;
745   struct dri2_display *pdp =
746      (struct dri2_display *) dpyPriv->dri2Display;
747   struct dri2_screen *psc;
748
749   if (pdraw != NULL) {
750      psc = (struct dri2_screen *) base->psc;
751
752      if (psc->texBuffer->base.version >= 3 &&
753          psc->texBuffer->releaseTexBuffer != NULL) {
754         (*psc->texBuffer->releaseTexBuffer) (pcp->driContext,
755                                           pdraw->base.textureTarget,
756                                           pdraw->driDrawable);
757      }
758   }
759#endif
760}
761
762static const struct glx_context_vtable dri2_context_vtable = {
763   dri2_destroy_context,
764   dri2_bind_context,
765   dri2_unbind_context,
766   dri2_wait_gl,
767   dri2_wait_x,
768   DRI_glXUseXFont,
769   dri2_bind_tex_image,
770   dri2_release_tex_image,
771};
772
773static void
774dri2BindExtensions(struct dri2_screen *psc, const __DRIextension **extensions)
775{
776   int i;
777
778   __glXEnableDirectExtension(&psc->base, "GLX_SGI_video_sync");
779   __glXEnableDirectExtension(&psc->base, "GLX_SGI_swap_control");
780   __glXEnableDirectExtension(&psc->base, "GLX_MESA_swap_control");
781   __glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read");
782
783   /* FIXME: if DRI2 version supports it... */
784   __glXEnableDirectExtension(&psc->base, "INTEL_swap_event");
785
786   for (i = 0; extensions[i]; i++) {
787      if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) {
788	 psc->texBuffer = (__DRItexBufferExtension *) extensions[i];
789	 __glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap");
790      }
791
792      if ((strcmp(extensions[i]->name, __DRI2_FLUSH) == 0)) {
793	 psc->f = (__DRI2flushExtension *) extensions[i];
794	 /* internal driver extension, no GL extension exposed */
795      }
796
797      if ((strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0))
798	 psc->config = (__DRI2configQueryExtension *) extensions[i];
799   }
800}
801
802static const struct glx_screen_vtable dri2_screen_vtable = {
803   dri2_create_context
804};
805
806static struct glx_screen *
807dri2CreateScreen(int screen, struct glx_display * priv)
808{
809   const __DRIconfig **driver_configs;
810   const __DRIextension **extensions;
811   const struct dri2_display *const pdp = (struct dri2_display *)
812      priv->dri2Display;
813   struct dri2_screen *psc;
814   __GLXDRIscreen *psp;
815   char *driverName, *deviceName;
816   drm_magic_t magic;
817   int i;
818
819   psc = Xmalloc(sizeof *psc);
820   if (psc == NULL)
821      return NULL;
822
823   memset(psc, 0, sizeof *psc);
824   psc->fd = -1;
825
826   if (!glx_screen_init(&psc->base, screen, priv)) {
827      Xfree(psc);
828      return NULL;
829   }
830
831   if (!DRI2Connect(priv->dpy, RootWindow(priv->dpy, screen),
832		    &driverName, &deviceName)) {
833      glx_screen_cleanup(&psc->base);
834      XFree(psc);
835      return NULL;
836   }
837
838   psc->driver = driOpenDriver(driverName);
839   if (psc->driver == NULL) {
840      ErrorMessageF("driver pointer missing\n");
841      goto handle_error;
842   }
843
844   extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS);
845   if (extensions == NULL) {
846      ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
847      goto handle_error;
848   }
849
850   for (i = 0; extensions[i]; i++) {
851      if (strcmp(extensions[i]->name, __DRI_CORE) == 0)
852	 psc->core = (__DRIcoreExtension *) extensions[i];
853      if (strcmp(extensions[i]->name, __DRI_DRI2) == 0)
854	 psc->dri2 = (__DRIdri2Extension *) extensions[i];
855   }
856
857   if (psc->core == NULL || psc->dri2 == NULL) {
858      ErrorMessageF("core dri or dri2 extension not found\n");
859      goto handle_error;
860   }
861
862   psc->fd = open(deviceName, O_RDWR);
863   if (psc->fd < 0) {
864      ErrorMessageF("failed to open drm device: %s\n", strerror(errno));
865      goto handle_error;
866   }
867
868   if (drmGetMagic(psc->fd, &magic)) {
869      ErrorMessageF("failed to get magic\n");
870      goto handle_error;
871   }
872
873   if (!DRI2Authenticate(priv->dpy, RootWindow(priv->dpy, screen), magic)) {
874      ErrorMessageF("failed to authenticate magic %d\n", magic);
875      goto handle_error;
876   }
877
878
879   /* If the server does not support the protocol for
880    * DRI2GetBuffersWithFormat, don't supply that interface to the driver.
881    */
882   psc->driScreen =
883      psc->dri2->createNewScreen(screen, psc->fd,
884				 (const __DRIextension **)
885				 &pdp->loader_extensions[0],
886				 &driver_configs, psc);
887
888   if (psc->driScreen == NULL) {
889      ErrorMessageF("failed to create dri screen\n");
890      goto handle_error;
891   }
892
893   extensions = psc->core->getExtensions(psc->driScreen);
894   dri2BindExtensions(psc, extensions);
895
896   psc->base.configs =
897      driConvertConfigs(psc->core, psc->base.configs, driver_configs);
898   psc->base.visuals =
899      driConvertConfigs(psc->core, psc->base.visuals, driver_configs);
900
901   psc->driver_configs = driver_configs;
902
903   psc->base.vtable = &dri2_screen_vtable;
904   psp = &psc->vtable;
905   psc->base.driScreen = psp;
906   psp->destroyScreen = dri2DestroyScreen;
907   psp->createDrawable = dri2CreateDrawable;
908   psp->swapBuffers = dri2SwapBuffers;
909   psp->getDrawableMSC = NULL;
910   psp->waitForMSC = NULL;
911   psp->waitForSBC = NULL;
912   psp->setSwapInterval = NULL;
913   psp->getSwapInterval = NULL;
914
915   if (pdp->driMinor >= 2) {
916#ifdef X_DRI2GetMSC
917      psp->getDrawableMSC = dri2DrawableGetMSC;
918#endif
919#ifdef X_DRI2WaitMSC
920      psp->waitForMSC = dri2WaitForMSC;
921      psp->waitForSBC = dri2WaitForSBC;
922#endif
923#ifdef X_DRI2SwapInterval
924      psp->setSwapInterval = dri2SetSwapInterval;
925      psp->getSwapInterval = dri2GetSwapInterval;
926#endif
927#if defined(X_DRI2GetMSC) && defined(X_DRI2WaitMSC) && defined(X_DRI2SwapInterval)
928      __glXEnableDirectExtension(&psc->base, "GLX_OML_sync_control");
929#endif
930   }
931
932   /* DRI2 suports SubBuffer through DRI2CopyRegion, so it's always
933    * available.*/
934   psp->copySubBuffer = dri2CopySubBuffer;
935   __glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer");
936
937   Xfree(driverName);
938   Xfree(deviceName);
939
940   return &psc->base;
941
942handle_error:
943   if (psc->fd >= 0)
944      close(psc->fd);
945   if (psc->driver)
946      dlclose(psc->driver);
947   Xfree(driverName);
948   Xfree(deviceName);
949   glx_screen_cleanup(&psc->base);
950   XFree(psc);
951
952   return NULL;
953}
954
955/* Called from __glXFreeDisplayPrivate.
956 */
957static void
958dri2DestroyDisplay(__GLXDRIdisplay * dpy)
959{
960   struct dri2_display *pdp = (struct dri2_display *) dpy;
961
962   __glxHashDestroy(pdp->dri2Hash);
963   Xfree(dpy);
964}
965
966_X_HIDDEN __GLXDRIdrawable *
967dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id)
968{
969   struct glx_display *d = __glXInitialize(dpy);
970   struct dri2_display *pdp = (struct dri2_display *) d->dri2Display;
971   __GLXDRIdrawable *pdraw;
972
973   if (__glxHashLookup(pdp->dri2Hash, id, (void *) &pdraw) == 0)
974      return pdraw;
975
976   return NULL;
977}
978
979/*
980 * Allocate, initialize and return a __DRIdisplayPrivate object.
981 * This is called from __glXInitialize() when we are given a new
982 * display pointer.
983 */
984_X_HIDDEN __GLXDRIdisplay *
985dri2CreateDisplay(Display * dpy)
986{
987   struct dri2_display *pdp;
988   int eventBase, errorBase, i;
989
990   if (!DRI2QueryExtension(dpy, &eventBase, &errorBase))
991      return NULL;
992
993   pdp = Xmalloc(sizeof *pdp);
994   if (pdp == NULL)
995      return NULL;
996
997   if (!DRI2QueryVersion(dpy, &pdp->driMajor, &pdp->driMinor)) {
998      Xfree(pdp);
999      return NULL;
1000   }
1001
1002   pdp->driPatch = 0;
1003   pdp->swapAvailable = (pdp->driMinor >= 2);
1004   pdp->invalidateAvailable = (pdp->driMinor >= 3);
1005
1006   pdp->base.destroyDisplay = dri2DestroyDisplay;
1007   pdp->base.createScreen = dri2CreateScreen;
1008
1009   i = 0;
1010   if (pdp->driMinor < 1)
1011      pdp->loader_extensions[i++] = &dri2LoaderExtension_old.base;
1012   else
1013      pdp->loader_extensions[i++] = &dri2LoaderExtension.base;
1014
1015   pdp->loader_extensions[i++] = &systemTimeExtension.base;
1016
1017#ifdef __DRI_USE_INVALIDATE
1018   pdp->loader_extensions[i++] = &dri2UseInvalidate.base;
1019#endif
1020   pdp->loader_extensions[i++] = NULL;
1021
1022   pdp->dri2Hash = __glxHashCreate();
1023   if (pdp->dri2Hash == NULL) {
1024      Xfree(pdp);
1025      return NULL;
1026   }
1027
1028   return &pdp->base;
1029}
1030
1031#endif /* GLX_DIRECT_RENDERING */
1032