2 * Copyright © 2008 Red Hat, Inc.
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.
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.
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.
30 * Kristian Høgsberg (krh@redhat.com)
33 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
36 #include <X11/extensions/Xfixes.h>
37 #include <X11/extensions/Xdamage.h>
39 #include "glxclient.h"
40 #include <X11/extensions/dri2proto.h>
45 #include <sys/types.h>
49 #include "dri_common.h"
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
60 typedef struct __GLXDRIdisplayPrivateRec __GLXDRIdisplayPrivate
;
61 typedef struct __GLXDRIcontextPrivateRec __GLXDRIcontextPrivate
;
62 typedef struct __GLXDRIdrawablePrivateRec __GLXDRIdrawablePrivate
;
64 struct __GLXDRIdisplayPrivateRec
69 ** XFree86-DRI version information
75 int invalidateAvailable
;
77 __glxHashTable
*dri2Hash
;
79 const __DRIextension
*loader_extensions
[4];
82 struct __GLXDRIcontextPrivateRec
85 __DRIcontext
*driContext
;
86 __GLXscreenConfigs
*psc
;
89 struct __GLXDRIdrawablePrivateRec
91 __GLXDRIdrawable base
;
92 __DRIbuffer buffers
[5];
101 dri2DestroyContext(__GLXDRIcontext
* context
,
102 __GLXscreenConfigs
* psc
, Display
* dpy
)
104 __GLXDRIcontextPrivate
*pcp
= (__GLXDRIcontextPrivate
*) context
;
105 const __DRIcoreExtension
*core
= pcp
->psc
->core
;
107 (*core
->destroyContext
) (pcp
->driContext
);
113 dri2BindContext(__GLXDRIcontext
* context
,
114 __GLXDRIdrawable
* draw
, __GLXDRIdrawable
* read
)
116 __GLXDRIcontextPrivate
*pcp
= (__GLXDRIcontextPrivate
*) context
;
117 const __DRIcoreExtension
*core
= pcp
->psc
->core
;
119 return (*core
->bindContext
) (pcp
->driContext
,
120 draw
->driDrawable
, read
->driDrawable
);
124 dri2UnbindContext(__GLXDRIcontext
* context
)
126 __GLXDRIcontextPrivate
*pcp
= (__GLXDRIcontextPrivate
*) context
;
127 const __DRIcoreExtension
*core
= pcp
->psc
->core
;
129 (*core
->unbindContext
) (pcp
->driContext
);
132 static __GLXDRIcontext
*
133 dri2CreateContext(__GLXscreenConfigs
* psc
,
134 const __GLcontextModes
* mode
,
135 GLXContext gc
, GLXContext shareList
, int renderType
)
137 __GLXDRIcontextPrivate
*pcp
, *pcp_shared
;
138 __GLXDRIconfigPrivate
*config
= (__GLXDRIconfigPrivate
*) mode
;
139 __DRIcontext
*shared
= NULL
;
142 pcp_shared
= (__GLXDRIcontextPrivate
*) shareList
->driContext
;
143 shared
= pcp_shared
->driContext
;
146 pcp
= Xmalloc(sizeof *pcp
);
152 (*psc
->dri2
->createNewContext
) (psc
->__driScreen
,
153 config
->driConfig
, shared
, pcp
);
154 gc
->__driContext
= pcp
->driContext
;
156 if (pcp
->driContext
== NULL
) {
161 pcp
->base
.destroyContext
= dri2DestroyContext
;
162 pcp
->base
.bindContext
= dri2BindContext
;
163 pcp
->base
.unbindContext
= dri2UnbindContext
;
169 dri2DestroyDrawable(__GLXDRIdrawable
*pdraw
)
171 const __DRIcoreExtension
*core
= pdraw
->psc
->core
;
172 __GLXdisplayPrivate
*dpyPriv
;
173 __GLXDRIdisplayPrivate
*pdp
;
175 dpyPriv
= __glXInitialize(pdraw
->psc
->dpy
);
176 pdp
= (__GLXDRIdisplayPrivate
*)dpyPriv
->dri2Display
;
178 __glxHashDelete(pdp
->dri2Hash
, pdraw
->xDrawable
);
179 (*core
->destroyDrawable
) (pdraw
->driDrawable
);
180 DRI2DestroyDrawable(pdraw
->psc
->dpy
, pdraw
->xDrawable
);
184 static __GLXDRIdrawable
*
185 dri2CreateDrawable(__GLXscreenConfigs
* psc
,
187 GLXDrawable drawable
, const __GLcontextModes
* modes
)
189 __GLXDRIdrawablePrivate
*pdraw
;
190 __GLXDRIconfigPrivate
*config
= (__GLXDRIconfigPrivate
*) modes
;
191 __GLXdisplayPrivate
*dpyPriv
;
192 __GLXDRIdisplayPrivate
*pdp
;
193 GLint vblank_mode
= DRI_CONF_VBLANK_DEF_INTERVAL_1
;
195 pdraw
= Xmalloc(sizeof(*pdraw
));
199 pdraw
->base
.destroyDrawable
= dri2DestroyDrawable
;
200 pdraw
->base
.xDrawable
= xDrawable
;
201 pdraw
->base
.drawable
= drawable
;
202 pdraw
->base
.psc
= psc
;
203 pdraw
->bufferCount
= 0;
204 pdraw
->swap_interval
= 1; /* default may be overridden below */
205 pdraw
->have_back
= 0;
208 psc
->config
->configQueryi(psc
->__driScreen
, "vblank_mode", &vblank_mode
);
210 switch (vblank_mode
) {
211 case DRI_CONF_VBLANK_NEVER
:
212 case DRI_CONF_VBLANK_DEF_INTERVAL_0
:
213 pdraw
->swap_interval
= 0;
215 case DRI_CONF_VBLANK_DEF_INTERVAL_1
:
216 case DRI_CONF_VBLANK_ALWAYS_SYNC
:
218 pdraw
->swap_interval
= 1;
222 DRI2CreateDrawable(psc
->dpy
, xDrawable
);
224 dpyPriv
= __glXInitialize(psc
->dpy
);
225 pdp
= (__GLXDRIdisplayPrivate
*)dpyPriv
->dri2Display
;;
226 /* Create a new drawable */
227 pdraw
->base
.driDrawable
=
228 (*psc
->dri2
->createNewDrawable
) (psc
->__driScreen
,
229 config
->driConfig
, pdraw
);
231 if (!pdraw
->base
.driDrawable
) {
232 DRI2DestroyDrawable(psc
->dpy
, xDrawable
);
237 if (__glxHashInsert(pdp
->dri2Hash
, xDrawable
, pdraw
)) {
238 (*psc
->core
->destroyDrawable
) (pdraw
->base
.driDrawable
);
239 DRI2DestroyDrawable(psc
->dpy
, xDrawable
);
245 #ifdef X_DRI2SwapInterval
247 * Make sure server has the same swap interval we do for the new
250 if (pdp
->swapAvailable
)
251 DRI2SwapInterval(psc
->dpy
, xDrawable
, pdraw
->swap_interval
);
260 dri2DrawableGetMSC(__GLXscreenConfigs
*psc
, __GLXDRIdrawable
*pdraw
,
261 int64_t *ust
, int64_t *msc
, int64_t *sbc
)
263 return DRI2GetMSC(psc
->dpy
, pdraw
->xDrawable
, ust
, msc
, sbc
);
272 dri2WaitForMSC(__GLXDRIdrawable
*pdraw
, int64_t target_msc
, int64_t divisor
,
273 int64_t remainder
, int64_t *ust
, int64_t *msc
, int64_t *sbc
)
275 return DRI2WaitMSC(pdraw
->psc
->dpy
, pdraw
->xDrawable
, target_msc
, divisor
,
276 remainder
, ust
, msc
, sbc
);
280 dri2WaitForSBC(__GLXDRIdrawable
*pdraw
, int64_t target_sbc
, int64_t *ust
,
281 int64_t *msc
, int64_t *sbc
)
283 return DRI2WaitSBC(pdraw
->psc
->dpy
, pdraw
->xDrawable
, target_sbc
, ust
, msc
,
287 #endif /* X_DRI2WaitMSC */
290 dri2CopySubBuffer(__GLXDRIdrawable
*pdraw
, int x
, int y
, int width
, int height
)
292 __GLXDRIdrawablePrivate
*priv
= (__GLXDRIdrawablePrivate
*) pdraw
;
294 XserverRegion region
;
296 /* Check we have the right attachments */
297 if (!priv
->have_back
)
301 xrect
.y
= priv
->height
- y
- height
;
303 xrect
.height
= height
;
307 (*pdraw
->psc
->f
->flush
) (pdraw
->driDrawable
);
310 region
= XFixesCreateRegion(pdraw
->psc
->dpy
, &xrect
, 1);
311 DRI2CopyRegion(pdraw
->psc
->dpy
, pdraw
->xDrawable
, region
,
312 DRI2BufferFrontLeft
, DRI2BufferBackLeft
);
313 XFixesDestroyRegion(pdraw
->psc
->dpy
, region
);
315 /* Refresh the fake front (if present) after we just damaged the real
318 DRI2CopyRegion(pdraw
->psc
->dpy
, pdraw
->xDrawable
, region
,
319 DRI2BufferFakeFrontLeft
, DRI2BufferFrontLeft
);
320 XFixesDestroyRegion(pdraw
->psc
->dpy
, region
);
324 dri2_copy_drawable(__GLXDRIdrawablePrivate
*priv
, int dest
, int src
)
327 XserverRegion region
;
328 __GLXscreenConfigs
*const psc
= priv
->base
.psc
;
332 xrect
.width
= priv
->width
;
333 xrect
.height
= priv
->height
;
337 (*psc
->f
->flush
) (priv
->base
.driDrawable
);
340 region
= XFixesCreateRegion(psc
->dpy
, &xrect
, 1);
341 DRI2CopyRegion(psc
->dpy
, priv
->base
.xDrawable
, region
, dest
, src
);
342 XFixesDestroyRegion(psc
->dpy
, region
);
347 dri2WaitX(__GLXDRIdrawable
*pdraw
)
349 __GLXDRIdrawablePrivate
*priv
= (__GLXDRIdrawablePrivate
*) pdraw
;
351 if (!priv
->have_fake_front
)
354 dri2_copy_drawable(priv
, DRI2BufferFakeFrontLeft
, DRI2BufferFrontLeft
);
358 dri2WaitGL(__GLXDRIdrawable
* pdraw
)
360 __GLXDRIdrawablePrivate
*priv
= (__GLXDRIdrawablePrivate
*) pdraw
;
362 if (!priv
->have_fake_front
)
365 dri2_copy_drawable(priv
, DRI2BufferFrontLeft
, DRI2BufferFakeFrontLeft
);
369 dri2FlushFrontBuffer(__DRIdrawable
*driDrawable
, void *loaderPrivate
)
371 __GLXDRIdrawablePrivate
*pdraw
= loaderPrivate
;
372 __GLXdisplayPrivate
*priv
= __glXInitialize(pdraw
->base
.psc
->dpy
);
373 __GLXDRIdisplayPrivate
*pdp
= (__GLXDRIdisplayPrivate
*)priv
->dri2Display
;
375 /* Old servers don't send invalidate events */
376 if (!pdp
->invalidateAvailable
)
377 dri2InvalidateBuffers(priv
->dpy
, pdraw
->base
.drawable
);
379 dri2WaitGL(loaderPrivate
);
384 dri2DestroyScreen(__GLXscreenConfigs
* psc
)
386 /* Free the direct rendering per screen data */
387 (*psc
->core
->destroyScreen
) (psc
->__driScreen
);
389 psc
->__driScreen
= NULL
;
393 * Process list of buffer received from the server
395 * Processes the list of buffers received in a reply from the server to either
396 * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat.
399 process_buffers(__GLXDRIdrawablePrivate
* pdraw
, DRI2Buffer
* buffers
,
404 pdraw
->bufferCount
= count
;
405 pdraw
->have_fake_front
= 0;
406 pdraw
->have_back
= 0;
408 /* This assumes the DRI2 buffer attachment tokens matches the
409 * __DRIbuffer tokens. */
410 for (i
= 0; i
< count
; i
++) {
411 pdraw
->buffers
[i
].attachment
= buffers
[i
].attachment
;
412 pdraw
->buffers
[i
].name
= buffers
[i
].name
;
413 pdraw
->buffers
[i
].pitch
= buffers
[i
].pitch
;
414 pdraw
->buffers
[i
].cpp
= buffers
[i
].cpp
;
415 pdraw
->buffers
[i
].flags
= buffers
[i
].flags
;
416 if (pdraw
->buffers
[i
].attachment
== __DRI_BUFFER_FAKE_FRONT_LEFT
)
417 pdraw
->have_fake_front
= 1;
418 if (pdraw
->buffers
[i
].attachment
== __DRI_BUFFER_BACK_LEFT
)
419 pdraw
->have_back
= 1;
425 dri2SwapBuffers(__GLXDRIdrawable
*pdraw
, int64_t target_msc
, int64_t divisor
,
428 __GLXDRIdrawablePrivate
*priv
= (__GLXDRIdrawablePrivate
*) pdraw
;
429 __GLXdisplayPrivate
*dpyPriv
= __glXInitialize(priv
->base
.psc
->dpy
);
430 __GLXDRIdisplayPrivate
*pdp
=
431 (__GLXDRIdisplayPrivate
*)dpyPriv
->dri2Display
;
436 (*pdraw
->psc
->f
->flush
)(pdraw
->driDrawable
);
439 /* Old servers don't send invalidate events */
440 if (!pdp
->invalidateAvailable
)
441 dri2InvalidateBuffers(dpyPriv
->dpy
, pdraw
->drawable
);
443 /* Old servers can't handle swapbuffers */
444 if (!pdp
->swapAvailable
) {
445 dri2CopySubBuffer(pdraw
, 0, 0, priv
->width
, priv
->height
);
449 #ifdef X_DRI2SwapBuffers
450 DRI2SwapBuffers(pdraw
->psc
->dpy
, pdraw
->xDrawable
, target_msc
, divisor
,
458 dri2GetBuffers(__DRIdrawable
* driDrawable
,
459 int *width
, int *height
,
460 unsigned int *attachments
, int count
,
461 int *out_count
, void *loaderPrivate
)
463 __GLXDRIdrawablePrivate
*pdraw
= loaderPrivate
;
466 buffers
= DRI2GetBuffers(pdraw
->base
.psc
->dpy
, pdraw
->base
.xDrawable
,
467 width
, height
, attachments
, count
, out_count
);
471 pdraw
->width
= *width
;
472 pdraw
->height
= *height
;
473 process_buffers(pdraw
, buffers
, *out_count
);
477 return pdraw
->buffers
;
481 dri2GetBuffersWithFormat(__DRIdrawable
* driDrawable
,
482 int *width
, int *height
,
483 unsigned int *attachments
, int count
,
484 int *out_count
, void *loaderPrivate
)
486 __GLXDRIdrawablePrivate
*pdraw
= loaderPrivate
;
489 buffers
= DRI2GetBuffersWithFormat(pdraw
->base
.psc
->dpy
,
490 pdraw
->base
.xDrawable
,
491 width
, height
, attachments
,
496 pdraw
->width
= *width
;
497 pdraw
->height
= *height
;
498 process_buffers(pdraw
, buffers
, *out_count
);
502 return pdraw
->buffers
;
505 #ifdef X_DRI2SwapInterval
508 dri2SetSwapInterval(__GLXDRIdrawable
*pdraw
, int interval
)
510 __GLXscreenConfigs
*psc
= pdraw
->psc
;
511 __GLXDRIdrawablePrivate
*priv
= (__GLXDRIdrawablePrivate
*) pdraw
;
512 GLint vblank_mode
= DRI_CONF_VBLANK_DEF_INTERVAL_1
;
515 psc
->config
->configQueryi(psc
->__driScreen
, "vblank_mode", &vblank_mode
);
517 switch (vblank_mode
) {
518 case DRI_CONF_VBLANK_NEVER
:
520 case DRI_CONF_VBLANK_ALWAYS_SYNC
:
528 DRI2SwapInterval(priv
->base
.psc
->dpy
, pdraw
->xDrawable
, interval
);
529 priv
->swap_interval
= interval
;
533 dri2GetSwapInterval(__GLXDRIdrawable
*pdraw
)
535 __GLXDRIdrawablePrivate
*priv
= (__GLXDRIdrawablePrivate
*) pdraw
;
537 return priv
->swap_interval
;
540 #endif /* X_DRI2SwapInterval */
542 static const __DRIdri2LoaderExtension dri2LoaderExtension
= {
543 {__DRI_DRI2_LOADER
, __DRI_DRI2_LOADER_VERSION
},
545 dri2FlushFrontBuffer
,
546 dri2GetBuffersWithFormat
,
549 static const __DRIdri2LoaderExtension dri2LoaderExtension_old
= {
550 {__DRI_DRI2_LOADER
, __DRI_DRI2_LOADER_VERSION
},
552 dri2FlushFrontBuffer
,
556 #ifdef __DRI_USE_INVALIDATE
557 static const __DRIuseInvalidateExtension dri2UseInvalidate
= {
558 { __DRI_USE_INVALIDATE
, __DRI_USE_INVALIDATE_VERSION
}
563 dri2InvalidateBuffers(Display
*dpy
, XID drawable
)
565 __GLXDRIdrawable
*pdraw
=
566 dri2GetGlxDrawableFromXDrawableId(dpy
, drawable
);
568 #if __DRI2_FLUSH_VERSION >= 3
569 if (pdraw
&& pdraw
->psc
->f
)
570 pdraw
->psc
->f
->invalidate(pdraw
->driDrawable
);
575 dri2_bind_tex_image(Display
* dpy
,
576 GLXDrawable drawable
,
577 int buffer
, const int *attrib_list
)
579 GLXContext gc
= __glXGetCurrentContext();
580 __GLXDRIdrawable
*pdraw
= GetGLXDRIDrawable(dpy
, drawable
, NULL
);
581 __GLXdisplayPrivate
*dpyPriv
= __glXInitialize(dpy
);
582 __GLXDRIdisplayPrivate
*pdp
=
583 (__GLXDRIdisplayPrivate
*) dpyPriv
->dri2Display
;
587 #if __DRI2_FLUSH_VERSION >= 3
588 if (!pdp
->invalidateAvailable
&& pdraw
->psc
->f
)
589 pdraw
->psc
->f
->invalidate(pdraw
->driDrawable
);
592 if (pdraw
->psc
->texBuffer
->base
.version
>= 2 &&
593 pdraw
->psc
->texBuffer
->setTexBuffer2
!= NULL
) {
594 (*pdraw
->psc
->texBuffer
->setTexBuffer2
) (gc
->__driContext
,
595 pdraw
->textureTarget
,
596 pdraw
->textureFormat
,
600 (*pdraw
->psc
->texBuffer
->setTexBuffer
) (gc
->__driContext
,
601 pdraw
->textureTarget
,
608 dri2_release_tex_image(Display
* dpy
, GLXDrawable drawable
, int buffer
)
612 static const struct glx_context_vtable dri2_context_vtable
= {
614 dri2_release_tex_image
,
617 static __GLXDRIscreen
*
618 dri2CreateScreen(__GLXscreenConfigs
* psc
, int screen
,
619 __GLXdisplayPrivate
* priv
)
621 const __DRIconfig
**driver_configs
;
622 const __DRIextension
**extensions
;
623 const __GLXDRIdisplayPrivate
*const pdp
= (__GLXDRIdisplayPrivate
*)
626 char *driverName
, *deviceName
;
630 psp
= Xmalloc(sizeof *psp
);
634 if (!DRI2Connect(psc
->dpy
, RootWindow(psc
->dpy
, screen
),
635 &driverName
, &deviceName
)) {
640 psc
->driver
= driOpenDriver(driverName
);
641 if (psc
->driver
== NULL
) {
642 ErrorMessageF("driver pointer missing\n");
646 extensions
= dlsym(psc
->driver
, __DRI_DRIVER_EXTENSIONS
);
647 if (extensions
== NULL
) {
648 ErrorMessageF("driver exports no extensions (%s)\n", dlerror());
652 for (i
= 0; extensions
[i
]; i
++) {
653 if (strcmp(extensions
[i
]->name
, __DRI_CORE
) == 0)
654 psc
->core
= (__DRIcoreExtension
*) extensions
[i
];
655 if (strcmp(extensions
[i
]->name
, __DRI_DRI2
) == 0)
656 psc
->dri2
= (__DRIdri2Extension
*) extensions
[i
];
659 if (psc
->core
== NULL
|| psc
->dri2
== NULL
) {
660 ErrorMessageF("core dri or dri2 extension not found\n");
664 psc
->fd
= open(deviceName
, O_RDWR
);
666 ErrorMessageF("failed to open drm device: %s\n", strerror(errno
));
670 if (drmGetMagic(psc
->fd
, &magic
)) {
671 ErrorMessageF("failed to get magic\n");
675 if (!DRI2Authenticate(psc
->dpy
, RootWindow(psc
->dpy
, screen
), magic
)) {
676 ErrorMessageF("failed to authenticate magic %d\n", magic
);
681 /* If the server does not support the protocol for
682 * DRI2GetBuffersWithFormat, don't supply that interface to the driver.
685 psc
->dri2
->createNewScreen(screen
, psc
->fd
,
686 (const __DRIextension
**)
687 &pdp
->loader_extensions
[0],
688 &driver_configs
, psc
);
690 if (psc
->__driScreen
== NULL
) {
691 ErrorMessageF("failed to create dri screen\n");
695 driBindCommonExtensions(psc
);
696 dri2BindExtensions(psc
);
698 psc
->configs
= driConvertConfigs(psc
->core
, psc
->configs
, driver_configs
);
699 psc
->visuals
= driConvertConfigs(psc
->core
, psc
->visuals
, driver_configs
);
701 psc
->driver_configs
= driver_configs
;
703 psp
->destroyScreen
= dri2DestroyScreen
;
704 psp
->createContext
= dri2CreateContext
;
705 psp
->createDrawable
= dri2CreateDrawable
;
706 psp
->swapBuffers
= dri2SwapBuffers
;
707 psp
->waitGL
= dri2WaitGL
;
708 psp
->waitX
= dri2WaitX
;
709 psp
->getDrawableMSC
= NULL
;
710 psp
->waitForMSC
= NULL
;
711 psp
->waitForSBC
= NULL
;
712 psp
->setSwapInterval
= NULL
;
713 psp
->getSwapInterval
= NULL
;
715 if (pdp
->driMinor
>= 2) {
717 psp
->getDrawableMSC
= dri2DrawableGetMSC
;
720 psp
->waitForMSC
= dri2WaitForMSC
;
721 psp
->waitForSBC
= dri2WaitForSBC
;
723 #ifdef X_DRI2SwapInterval
724 psp
->setSwapInterval
= dri2SetSwapInterval
;
725 psp
->getSwapInterval
= dri2GetSwapInterval
;
727 #if defined(X_DRI2GetMSC) && defined(X_DRI2WaitMSC) && defined(X_DRI2SwapInterval)
728 __glXEnableDirectExtension(psc
, "GLX_OML_sync_control");
732 /* DRI2 suports SubBuffer through DRI2CopyRegion, so it's always
734 psp
->copySubBuffer
= dri2CopySubBuffer
;
735 __glXEnableDirectExtension(psc
, "GLX_MESA_copy_sub_buffer");
737 psc
->direct_context_vtable
= &dri2_context_vtable
;
749 /* FIXME: clean up here */
754 /* Called from __glXFreeDisplayPrivate.
757 dri2DestroyDisplay(__GLXDRIdisplay
* dpy
)
762 _X_HIDDEN __GLXDRIdrawable
*
763 dri2GetGlxDrawableFromXDrawableId(Display
*dpy
, XID id
)
765 __GLXdisplayPrivate
*d
= __glXInitialize(dpy
);
766 __GLXDRIdisplayPrivate
*pdp
= (__GLXDRIdisplayPrivate
*) d
->dri2Display
;
767 __GLXDRIdrawable
*pdraw
;
769 if (__glxHashLookup(pdp
->dri2Hash
, id
, (void *) &pdraw
) == 0)
776 * Allocate, initialize and return a __DRIdisplayPrivate object.
777 * This is called from __glXInitialize() when we are given a new
780 _X_HIDDEN __GLXDRIdisplay
*
781 dri2CreateDisplay(Display
* dpy
)
783 __GLXDRIdisplayPrivate
*pdp
;
784 int eventBase
, errorBase
, i
;
786 if (!DRI2QueryExtension(dpy
, &eventBase
, &errorBase
))
789 pdp
= Xmalloc(sizeof *pdp
);
793 if (!DRI2QueryVersion(dpy
, &pdp
->driMajor
, &pdp
->driMinor
)) {
799 pdp
->swapAvailable
= (pdp
->driMinor
>= 2);
800 pdp
->invalidateAvailable
= (pdp
->driMinor
>= 3);
802 pdp
->base
.destroyDisplay
= dri2DestroyDisplay
;
803 pdp
->base
.createScreen
= dri2CreateScreen
;
806 if (pdp
->driMinor
< 1)
807 pdp
->loader_extensions
[i
++] = &dri2LoaderExtension_old
.base
;
809 pdp
->loader_extensions
[i
++] = &dri2LoaderExtension
.base
;
811 pdp
->loader_extensions
[i
++] = &systemTimeExtension
.base
;
813 #ifdef __DRI_USE_INVALIDATE
814 pdp
->loader_extensions
[i
++] = &dri2UseInvalidate
.base
;
816 pdp
->loader_extensions
[i
++] = NULL
;
818 pdp
->dri2Hash
= __glxHashCreate();
819 if (pdp
->dri2Hash
== NULL
) {
827 #endif /* GLX_DIRECT_RENDERING */