X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglx%2Fdri2_glx.c;h=91afc3375058d9f7e67e5aa3f808d9878b95e60b;hb=faa29c0e2449e3d7521bc273d723012b537593df;hp=06f3d8b71c02a876ebcee5165a9fe1ebed9b8a36;hpb=d9793fc3ac0986f8665e269ecf993705132d0360;p=mesa.git diff --git a/src/glx/dri2_glx.c b/src/glx/dri2_glx.c index 06f3d8b71c0..91afc337505 100644 --- a/src/glx/dri2_glx.c +++ b/src/glx/dri2_glx.c @@ -30,33 +30,36 @@ * Kristian Høgsberg (krh@redhat.com) */ -#ifdef GLX_DIRECT_RENDERING +#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) #include #include -#include -#include "glapi.h" +#include +#include +#include #include "glxclient.h" #include -#include "xf86dri.h" #include #include #include #include #include -#include "xf86drm.h" +#include #include "dri2.h" #include "dri_common.h" -#include "../../mesa/drivers/dri/common/dri_util.h" +#include "dri2_priv.h" +#include "loader.h" + +/* From xmlpool/options.h, user exposed so should be stable */ +#define DRI_CONF_VBLANK_NEVER 0 +#define DRI_CONF_VBLANK_DEF_INTERVAL_0 1 +#define DRI_CONF_VBLANK_DEF_INTERVAL_1 2 +#define DRI_CONF_VBLANK_ALWAYS_SYNC 3 #undef DRI2_MINOR #define DRI2_MINOR 1 -typedef struct __GLXDRIdisplayPrivateRec __GLXDRIdisplayPrivate; -typedef struct __GLXDRIcontextPrivateRec __GLXDRIcontextPrivate; -typedef struct __GLXDRIdrawablePrivateRec __GLXDRIdrawablePrivate; - -struct __GLXDRIdisplayPrivateRec +struct dri2_display { __GLXDRIdisplay base; @@ -68,179 +71,514 @@ struct __GLXDRIdisplayPrivateRec int driPatch; int swapAvailable; int invalidateAvailable; -}; -struct __GLXDRIcontextPrivateRec -{ - __GLXDRIcontext base; - __DRIcontext *driContext; - __GLXscreenConfigs *psc; + __glxHashTable *dri2Hash; + + const __DRIextension *loader_extensions[5]; }; -struct __GLXDRIdrawablePrivateRec +struct dri2_drawable { __GLXDRIdrawable base; + __DRIdrawable *driDrawable; __DRIbuffer buffers[5]; int bufferCount; int width, height; int have_back; int have_fake_front; int swap_interval; + + uint64_t previous_time; + unsigned frames; }; -static void dri2WaitX(__GLXDRIdrawable * pdraw); +static const struct glx_context_vtable dri2_context_vtable; +/* For XCB's handling of ust/msc/sbc counters, we have to hand it the high and + * low halves separately. This helps you split them. + */ static void -dri2DestroyContext(__GLXDRIcontext * context, - __GLXscreenConfigs * psc, Display * dpy) +split_counter(uint64_t counter, uint32_t *hi, uint32_t *lo) { - __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context; - const __DRIcoreExtension *core = pcp->psc->core; + *hi = (counter >> 32); + *lo = counter & 0xffffffff; +} - (*core->destroyContext) (pcp->driContext); +static uint64_t +merge_counter(uint32_t hi, uint32_t lo) +{ + return ((uint64_t)hi << 32) | lo; +} + +static void +dri2_destroy_context(struct glx_context *context) +{ + struct dri2_context *pcp = (struct dri2_context *) context; + struct dri2_screen *psc = (struct dri2_screen *) context->psc; - Xfree(pcp); + driReleaseDrawables(&pcp->base); + + free((char *) context->extensions); + + (*psc->core->destroyContext) (pcp->driContext); + + free(pcp); } static Bool -dri2BindContext(__GLXDRIcontext * context, - __GLXDRIdrawable * draw, __GLXDRIdrawable * read) +dri2_bind_context(struct glx_context *context, struct glx_context *old, + GLXDrawable draw, GLXDrawable read) { - __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context; - const __DRIcoreExtension *core = pcp->psc->core; + struct dri2_context *pcp = (struct dri2_context *) context; + struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc; + struct dri2_drawable *pdraw, *pread; + __DRIdrawable *dri_draw = NULL, *dri_read = NULL; + struct glx_display *dpyPriv = psc->base.display; + struct dri2_display *pdp; + + pdraw = (struct dri2_drawable *) driFetchDrawable(context, draw); + pread = (struct dri2_drawable *) driFetchDrawable(context, read); + + driReleaseDrawables(&pcp->base); + + if (pdraw) + dri_draw = pdraw->driDrawable; + else if (draw != None) + return GLXBadDrawable; + + if (pread) + dri_read = pread->driDrawable; + else if (read != None) + return GLXBadDrawable; + + if (!(*psc->core->bindContext) (pcp->driContext, dri_draw, dri_read)) + return GLXBadContext; + + /* If the server doesn't send invalidate events, we may miss a + * resize before the rendering starts. Invalidate the buffers now + * so the driver will recheck before rendering starts. */ + pdp = (struct dri2_display *) dpyPriv->dri2Display; + if (!pdp->invalidateAvailable && pdraw) { + dri2InvalidateBuffers(psc->base.dpy, pdraw->base.xDrawable); + if (pread != pdraw && pread) + dri2InvalidateBuffers(psc->base.dpy, pread->base.xDrawable); + } - return (*core->bindContext) (pcp->driContext, - draw->driDrawable, read->driDrawable); + return Success; } static void -dri2UnbindContext(__GLXDRIcontext * context) +dri2_unbind_context(struct glx_context *context, struct glx_context *new) { - __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context; - const __DRIcoreExtension *core = pcp->psc->core; + struct dri2_context *pcp = (struct dri2_context *) context; + struct dri2_screen *psc = (struct dri2_screen *) pcp->base.psc; - (*core->unbindContext) (pcp->driContext); + (*psc->core->unbindContext) (pcp->driContext); } -static __GLXDRIcontext * -dri2CreateContext(__GLXscreenConfigs * psc, - const __GLcontextModes * mode, - GLXContext gc, GLXContext shareList, int renderType) +static struct glx_context * +dri2_create_context(struct glx_screen *base, + struct glx_config *config_base, + struct glx_context *shareList, int renderType) { - __GLXDRIcontextPrivate *pcp, *pcp_shared; - __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) mode; + struct dri2_context *pcp, *pcp_shared; + struct dri2_screen *psc = (struct dri2_screen *) base; + __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base; __DRIcontext *shared = NULL; + /* Check the renderType value */ + if (!validate_renderType_against_config(config_base, renderType)) + return NULL; + if (shareList) { - pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext; + /* If the shareList context is not a DRI2 context, we cannot possibly + * create a DRI2 context that shares it. + */ + if (shareList->vtable->destroy != dri2_destroy_context) { + return NULL; + } + + pcp_shared = (struct dri2_context *) shareList; shared = pcp_shared->driContext; } - pcp = Xmalloc(sizeof *pcp); + pcp = calloc(1, sizeof *pcp); if (pcp == NULL) return NULL; - pcp->psc = psc; + if (!glx_context_init(&pcp->base, &psc->base, &config->base)) { + free(pcp); + return NULL; + } + + pcp->base.renderType = renderType; + pcp->driContext = - (*psc->dri2->createNewContext) (psc->__driScreen, + (*psc->dri2->createNewContext) (psc->driScreen, config->driConfig, shared, pcp); - gc->__driContext = pcp->driContext; if (pcp->driContext == NULL) { - Xfree(pcp); + free(pcp); return NULL; } - pcp->base.destroyContext = dri2DestroyContext; - pcp->base.bindContext = dri2BindContext; - pcp->base.unbindContext = dri2UnbindContext; + pcp->base.vtable = &dri2_context_vtable; return &pcp->base; } -static void -dri2DestroyDrawable(__GLXDRIdrawable * pdraw) +static struct glx_context * +dri2_create_context_attribs(struct glx_screen *base, + struct glx_config *config_base, + struct glx_context *shareList, + unsigned num_attribs, + const uint32_t *attribs, + unsigned *error) { - const __DRIcoreExtension *core = pdraw->psc->core; + struct dri2_context *pcp = NULL; + struct dri2_context *pcp_shared = NULL; + struct dri2_screen *psc = (struct dri2_screen *) base; + __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base; + __DRIcontext *shared = NULL; + + uint32_t minor_ver; + uint32_t major_ver; + uint32_t renderType; + uint32_t flags; + unsigned api; + int reset; + int release; + uint32_t ctx_attribs[2 * 6]; + unsigned num_ctx_attribs = 0; + + if (psc->dri2->base.version < 3) { + *error = __DRI_CTX_ERROR_NO_MEMORY; + goto error_exit; + } + + /* Remap the GLX tokens to DRI2 tokens. + */ + if (!dri2_convert_glx_attribs(num_attribs, attribs, + &major_ver, &minor_ver, &renderType, &flags, + &api, &reset, &release, error)) + goto error_exit; + + /* Check the renderType value */ + if (!validate_renderType_against_config(config_base, renderType)) + goto error_exit; + + if (shareList) { + pcp_shared = (struct dri2_context *) shareList; + shared = pcp_shared->driContext; + } - (*core->destroyDrawable) (pdraw->driDrawable); - DRI2DestroyDrawable(pdraw->psc->dpy, pdraw->xDrawable); - Xfree(pdraw); + pcp = calloc(1, sizeof *pcp); + if (pcp == NULL) { + *error = __DRI_CTX_ERROR_NO_MEMORY; + goto error_exit; + } + + if (!glx_context_init(&pcp->base, &psc->base, config_base)) + goto error_exit; + + ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MAJOR_VERSION; + ctx_attribs[num_ctx_attribs++] = major_ver; + ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_MINOR_VERSION; + ctx_attribs[num_ctx_attribs++] = minor_ver; + + /* Only send a value when the non-default value is requested. By doing + * this we don't have to check the driver's DRI2 version before sending the + * default value. + */ + if (reset != __DRI_CTX_RESET_NO_NOTIFICATION) { + ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RESET_STRATEGY; + ctx_attribs[num_ctx_attribs++] = reset; + } + + if (release != __DRI_CTX_RELEASE_BEHAVIOR_FLUSH) { + ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_RELEASE_BEHAVIOR; + ctx_attribs[num_ctx_attribs++] = release; + } + + if (flags != 0) { + ctx_attribs[num_ctx_attribs++] = __DRI_CTX_ATTRIB_FLAGS; + + /* The current __DRI_CTX_FLAG_* values are identical to the + * GLX_CONTEXT_*_BIT values. + */ + ctx_attribs[num_ctx_attribs++] = flags; + } + + /* The renderType is retrieved from attribs, or set to default + * of GLX_RGBA_TYPE. + */ + pcp->base.renderType = renderType; + + pcp->driContext = + (*psc->dri2->createContextAttribs) (psc->driScreen, + api, + config ? config->driConfig : NULL, + shared, + num_ctx_attribs / 2, + ctx_attribs, + error, + pcp); + + if (pcp->driContext == NULL) + goto error_exit; + + pcp->base.vtable = &dri2_context_vtable; + + return &pcp->base; + +error_exit: + free(pcp); + + return NULL; +} + +static void +dri2DestroyDrawable(__GLXDRIdrawable *base) +{ + struct dri2_screen *psc = (struct dri2_screen *) base->psc; + struct dri2_drawable *pdraw = (struct dri2_drawable *) base; + struct glx_display *dpyPriv = psc->base.display; + struct dri2_display *pdp = (struct dri2_display *)dpyPriv->dri2Display; + + __glxHashDelete(pdp->dri2Hash, pdraw->base.xDrawable); + (*psc->core->destroyDrawable) (pdraw->driDrawable); + + /* If it's a GLX 1.3 drawables, we can destroy the DRI2 drawable + * now, as the application explicitly asked to destroy the GLX + * drawable. Otherwise, for legacy drawables, we let the DRI2 + * drawable linger on the server, since there's no good way of + * knowing when the application is done with it. The server will + * destroy the DRI2 drawable when it destroys the X drawable or the + * client exits anyway. */ + if (pdraw->base.xDrawable != pdraw->base.drawable) + DRI2DestroyDrawable(psc->base.dpy, pdraw->base.xDrawable); + + free(pdraw); } static __GLXDRIdrawable * -dri2CreateDrawable(__GLXscreenConfigs * psc, - XID xDrawable, - GLXDrawable drawable, const __GLcontextModes * modes) +dri2CreateDrawable(struct glx_screen *base, XID xDrawable, + GLXDrawable drawable, struct glx_config *config_base) { - __GLXDRIdrawablePrivate *pdraw; - __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) modes; + struct dri2_drawable *pdraw; + struct dri2_screen *psc = (struct dri2_screen *) base; + __GLXDRIconfigPrivate *config = (__GLXDRIconfigPrivate *) config_base; + struct glx_display *dpyPriv; + struct dri2_display *pdp; + GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1; + + dpyPriv = __glXInitialize(psc->base.dpy); + if (dpyPriv == NULL) + return NULL; - pdraw = Xmalloc(sizeof(*pdraw)); + pdraw = calloc(1, sizeof(*pdraw)); if (!pdraw) return NULL; pdraw->base.destroyDrawable = dri2DestroyDrawable; pdraw->base.xDrawable = xDrawable; pdraw->base.drawable = drawable; - pdraw->base.psc = psc; + pdraw->base.psc = &psc->base; pdraw->bufferCount = 0; - pdraw->swap_interval = 0; + pdraw->swap_interval = 1; /* default may be overridden below */ + pdraw->have_back = 0; - DRI2CreateDrawable(psc->dpy, xDrawable); + if (psc->config) + psc->config->configQueryi(psc->driScreen, + "vblank_mode", &vblank_mode); + + switch (vblank_mode) { + case DRI_CONF_VBLANK_NEVER: + case DRI_CONF_VBLANK_DEF_INTERVAL_0: + pdraw->swap_interval = 0; + break; + case DRI_CONF_VBLANK_DEF_INTERVAL_1: + case DRI_CONF_VBLANK_ALWAYS_SYNC: + default: + pdraw->swap_interval = 1; + break; + } + DRI2CreateDrawable(psc->base.dpy, xDrawable); + pdp = (struct dri2_display *)dpyPriv->dri2Display; /* Create a new drawable */ - pdraw->base.driDrawable = - (*psc->dri2->createNewDrawable) (psc->__driScreen, + pdraw->driDrawable = + (*psc->dri2->createNewDrawable) (psc->driScreen, config->driConfig, pdraw); - if (!pdraw->base.driDrawable) { - DRI2DestroyDrawable(psc->dpy, xDrawable); - Xfree(pdraw); + if (!pdraw->driDrawable) { + DRI2DestroyDrawable(psc->base.dpy, xDrawable); + free(pdraw); return NULL; } + if (__glxHashInsert(pdp->dri2Hash, xDrawable, pdraw)) { + (*psc->core->destroyDrawable) (pdraw->driDrawable); + DRI2DestroyDrawable(psc->base.dpy, xDrawable); + free(pdraw); + return None; + } + + /* + * Make sure server has the same swap interval we do for the new + * drawable. + */ + if (psc->vtable.setSwapInterval) + psc->vtable.setSwapInterval(&pdraw->base, pdraw->swap_interval); + return &pdraw->base; } -#ifdef X_DRI2GetMSC - static int -dri2DrawableGetMSC(__GLXscreenConfigs *psc, __GLXDRIdrawable *pdraw, +dri2DrawableGetMSC(struct glx_screen *psc, __GLXDRIdrawable *pdraw, int64_t *ust, int64_t *msc, int64_t *sbc) { - return DRI2GetMSC(psc->dpy, pdraw->xDrawable, ust, msc, sbc); -} + xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy); + xcb_dri2_get_msc_cookie_t get_msc_cookie; + xcb_dri2_get_msc_reply_t *get_msc_reply; -#endif + get_msc_cookie = xcb_dri2_get_msc_unchecked(c, pdraw->xDrawable); + get_msc_reply = xcb_dri2_get_msc_reply(c, get_msc_cookie, NULL); + if (!get_msc_reply) + return 0; -#ifdef X_DRI2WaitMSC + *ust = merge_counter(get_msc_reply->ust_hi, get_msc_reply->ust_lo); + *msc = merge_counter(get_msc_reply->msc_hi, get_msc_reply->msc_lo); + *sbc = merge_counter(get_msc_reply->sbc_hi, get_msc_reply->sbc_lo); + free(get_msc_reply); + + return 1; +} static int dri2WaitForMSC(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t *ust, int64_t *msc, int64_t *sbc) { - return DRI2WaitMSC(pdraw->psc->dpy, pdraw->xDrawable, target_msc, divisor, - remainder, ust, msc, sbc); + xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy); + xcb_dri2_wait_msc_cookie_t wait_msc_cookie; + xcb_dri2_wait_msc_reply_t *wait_msc_reply; + uint32_t target_msc_hi, target_msc_lo; + uint32_t divisor_hi, divisor_lo; + uint32_t remainder_hi, remainder_lo; + + split_counter(target_msc, &target_msc_hi, &target_msc_lo); + split_counter(divisor, &divisor_hi, &divisor_lo); + split_counter(remainder, &remainder_hi, &remainder_lo); + + wait_msc_cookie = xcb_dri2_wait_msc_unchecked(c, pdraw->xDrawable, + target_msc_hi, target_msc_lo, + divisor_hi, divisor_lo, + remainder_hi, remainder_lo); + wait_msc_reply = xcb_dri2_wait_msc_reply(c, wait_msc_cookie, NULL); + + if (!wait_msc_reply) + return 0; + + *ust = merge_counter(wait_msc_reply->ust_hi, wait_msc_reply->ust_lo); + *msc = merge_counter(wait_msc_reply->msc_hi, wait_msc_reply->msc_lo); + *sbc = merge_counter(wait_msc_reply->sbc_hi, wait_msc_reply->sbc_lo); + free(wait_msc_reply); + + return 1; } static int dri2WaitForSBC(__GLXDRIdrawable *pdraw, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc) { - return DRI2WaitSBC(pdraw->psc->dpy, pdraw->xDrawable, target_sbc, ust, msc, - sbc); + xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy); + xcb_dri2_wait_sbc_cookie_t wait_sbc_cookie; + xcb_dri2_wait_sbc_reply_t *wait_sbc_reply; + uint32_t target_sbc_hi, target_sbc_lo; + + split_counter(target_sbc, &target_sbc_hi, &target_sbc_lo); + + wait_sbc_cookie = xcb_dri2_wait_sbc_unchecked(c, pdraw->xDrawable, + target_sbc_hi, target_sbc_lo); + wait_sbc_reply = xcb_dri2_wait_sbc_reply(c, wait_sbc_cookie, NULL); + + if (!wait_sbc_reply) + return 0; + + *ust = merge_counter(wait_sbc_reply->ust_hi, wait_sbc_reply->ust_lo); + *msc = merge_counter(wait_sbc_reply->msc_hi, wait_sbc_reply->msc_lo); + *sbc = merge_counter(wait_sbc_reply->sbc_hi, wait_sbc_reply->sbc_lo); + free(wait_sbc_reply); + + return 1; +} + +static __DRIcontext * +dri2GetCurrentContext() +{ + struct glx_context *gc = __glXGetCurrentContext(); + struct dri2_context *dri2Ctx = (struct dri2_context *)gc; + + return (gc != &dummyContext) ? dri2Ctx->driContext : NULL; +} + +/** + * dri2Throttle - Request driver throttling + * + * This function uses the DRI2 throttle extension to give the + * driver the opportunity to throttle on flush front, copysubbuffer + * and swapbuffers. + */ +static void +dri2Throttle(struct dri2_screen *psc, + struct dri2_drawable *draw, + enum __DRI2throttleReason reason) +{ + if (psc->throttle) { + __DRIcontext *ctx = dri2GetCurrentContext(); + + psc->throttle->throttle(ctx, draw->driDrawable, reason); + } } -#endif /* X_DRI2WaitMSC */ +/** + * Asks the driver to flush any queued work necessary for serializing with the + * X command stream, and optionally the slightly more strict requirement of + * glFlush() equivalence (which would require flushing even if nothing had + * been drawn to a window system framebuffer, for example). + */ +static void +dri2Flush(struct dri2_screen *psc, + __DRIcontext *ctx, + struct dri2_drawable *draw, + unsigned flags, + enum __DRI2throttleReason throttle_reason) +{ + if (ctx && psc->f && psc->f->base.version >= 4) { + psc->f->flush_with_flags(ctx, draw->driDrawable, flags, throttle_reason); + } else { + if (flags & __DRI2_FLUSH_CONTEXT) + glFlush(); + + if (psc->f) + psc->f->flush(draw->driDrawable); + + dri2Throttle(psc, draw, throttle_reason); + } +} static void -dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y, int width, int height) +__dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y, + int width, int height, + enum __DRI2throttleReason reason, Bool flush) { - __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw; + struct dri2_drawable *priv = (struct dri2_drawable *) pdraw; + struct dri2_screen *psc = (struct dri2_screen *) pdraw->psc; XRectangle xrect; XserverRegion region; + __DRIcontext *ctx = dri2GetCurrentContext(); + unsigned flags; /* Check we have the right attachments */ if (!priv->have_back) @@ -251,98 +589,128 @@ dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y, int width, int height) xrect.width = width; xrect.height = height; -#ifdef __DRI2_FLUSH - if (pdraw->psc->f) - (*pdraw->psc->f->flush) (pdraw->driDrawable); -#endif + flags = __DRI2_FLUSH_DRAWABLE; + if (flush) + flags |= __DRI2_FLUSH_CONTEXT; + dri2Flush(psc, ctx, priv, flags, __DRI2_THROTTLE_SWAPBUFFER); - region = XFixesCreateRegion(pdraw->psc->dpy, &xrect, 1); - /* should get a fence ID back from here at some point */ - DRI2CopyRegion(pdraw->psc->dpy, pdraw->xDrawable, region, + region = XFixesCreateRegion(psc->base.dpy, &xrect, 1); + DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region, DRI2BufferFrontLeft, DRI2BufferBackLeft); - XFixesDestroyRegion(pdraw->psc->dpy, region); /* Refresh the fake front (if present) after we just damaged the real * front. */ - dri2WaitX(pdraw); + if (priv->have_fake_front) + DRI2CopyRegion(psc->base.dpy, pdraw->xDrawable, region, + DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft); + + XFixesDestroyRegion(psc->base.dpy, region); +} + +static void +dri2CopySubBuffer(__GLXDRIdrawable *pdraw, int x, int y, + int width, int height, Bool flush) +{ + __dri2CopySubBuffer(pdraw, x, y, width, height, + __DRI2_THROTTLE_COPYSUBBUFFER, flush); } + static void -dri2WaitX(__GLXDRIdrawable *pdraw) +dri2_copy_drawable(struct dri2_drawable *priv, int dest, int src) { - __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw; XRectangle xrect; XserverRegion region; - - /* Check we have the right attachments */ - if (!priv->have_fake_front) - return; + struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc; xrect.x = 0; xrect.y = 0; xrect.width = priv->width; xrect.height = priv->height; -#ifdef __DRI2_FLUSH - if (pdraw->psc->f) - (*pdraw->psc->f->flush) (pdraw->driDrawable); -#endif + if (psc->f) + (*psc->f->flush) (priv->driDrawable); + + region = XFixesCreateRegion(psc->base.dpy, &xrect, 1); + DRI2CopyRegion(psc->base.dpy, priv->base.xDrawable, region, dest, src); + XFixesDestroyRegion(psc->base.dpy, region); - region = XFixesCreateRegion(pdraw->psc->dpy, &xrect, 1); - DRI2CopyRegion(pdraw->psc->dpy, pdraw->xDrawable, region, - DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft); - XFixesDestroyRegion(pdraw->psc->dpy, region); } static void -dri2WaitGL(__GLXDRIdrawable * pdraw) +dri2_wait_x(struct glx_context *gc) { - __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw; - XRectangle xrect; - XserverRegion region; + struct dri2_drawable *priv = (struct dri2_drawable *) + GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable); - if (!priv->have_fake_front) + if (priv == NULL || !priv->have_fake_front) return; - xrect.x = 0; - xrect.y = 0; - xrect.width = priv->width; - xrect.height = priv->height; + dri2_copy_drawable(priv, DRI2BufferFakeFrontLeft, DRI2BufferFrontLeft); +} + +static void +dri2_wait_gl(struct glx_context *gc) +{ + struct dri2_drawable *priv = (struct dri2_drawable *) + GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable); -#ifdef __DRI2_FLUSH - if (pdraw->psc->f) - (*pdraw->psc->f->flush) (pdraw->driDrawable); -#endif + if (priv == NULL || !priv->have_fake_front) + return; - region = XFixesCreateRegion(pdraw->psc->dpy, &xrect, 1); - DRI2CopyRegion(pdraw->psc->dpy, pdraw->xDrawable, region, - DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft); - XFixesDestroyRegion(pdraw->psc->dpy, region); + dri2_copy_drawable(priv, DRI2BufferFrontLeft, DRI2BufferFakeFrontLeft); } +/** + * Called by the driver when it needs to update the real front buffer with the + * contents of its fake front buffer. + */ static void dri2FlushFrontBuffer(__DRIdrawable *driDrawable, void *loaderPrivate) { - __GLXDRIdrawablePrivate *pdraw = loaderPrivate; - __GLXdisplayPrivate *priv = __glXInitialize(pdraw->base.psc->dpy); - __GLXDRIdisplayPrivate *pdp = (__GLXDRIdisplayPrivate *)priv->dri2Display; + struct glx_display *priv; + struct dri2_display *pdp; + struct glx_context *gc; + struct dri2_drawable *pdraw = loaderPrivate; + struct dri2_screen *psc; + + if (!pdraw) + return; + + if (!pdraw->base.psc) + return; + + psc = (struct dri2_screen *) pdraw->base.psc; + + priv = __glXInitialize(psc->base.dpy); + + if (priv == NULL) + return; + + pdp = (struct dri2_display *) priv->dri2Display; + gc = __glXGetCurrentContext(); + + dri2Throttle(psc, pdraw, __DRI2_THROTTLE_FLUSHFRONT); /* Old servers don't send invalidate events */ if (!pdp->invalidateAvailable) - dri2InvalidateBuffers(priv->dpy, pdraw->base.drawable); + dri2InvalidateBuffers(priv->dpy, pdraw->base.xDrawable); - dri2WaitGL(loaderPrivate); + dri2_wait_gl(gc); } static void -dri2DestroyScreen(__GLXscreenConfigs * psc) +dri2DestroyScreen(struct glx_screen *base) { + struct dri2_screen *psc = (struct dri2_screen *) base; + /* Free the direct rendering per screen data */ - (*psc->core->destroyScreen) (psc->__driScreen); + (*psc->core->destroyScreen) (psc->driScreen); + driDestroyConfigs(psc->driver_configs); close(psc->fd); - psc->__driScreen = NULL; + free(psc); } /** @@ -352,7 +720,7 @@ dri2DestroyScreen(__GLXscreenConfigs * psc) * \c DRI2GetBuffers or \c DRI2GetBuffersWithFormat. */ static void -process_buffers(__GLXDRIdrawablePrivate * pdraw, DRI2Buffer * buffers, +process_buffers(struct dri2_drawable * pdraw, DRI2Buffer * buffers, unsigned count) { int i; @@ -377,35 +745,122 @@ process_buffers(__GLXDRIdrawablePrivate * pdraw, DRI2Buffer * buffers, } +unsigned dri2GetSwapEventType(Display* dpy, XID drawable) +{ + struct glx_display *glx_dpy = __glXInitialize(dpy); + __GLXDRIdrawable *pdraw; + pdraw = dri2GetGlxDrawableFromXDrawableId(dpy, drawable); + if (!pdraw || !(pdraw->eventMask & GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK)) + return 0; + return glx_dpy->codes->first_event + GLX_BufferSwapComplete; +} + +static void show_fps(struct dri2_drawable *draw) +{ + const int interval = + ((struct dri2_screen *) draw->base.psc)->show_fps_interval; + struct timeval tv; + uint64_t current_time; + + gettimeofday(&tv, 0); + current_time = (uint64_t)tv.tv_sec*1000000 + (uint64_t)tv.tv_usec; + + draw->frames++; + + if (draw->previous_time + interval * 1000000 <= current_time) { + if (draw->previous_time) { + fprintf(stderr, "libGL: FPS = %.1f\n", + ((uint64_t)draw->frames * 1000000) / + (double)(current_time - draw->previous_time)); + } + draw->frames = 0; + draw->previous_time = current_time; + } +} + +static int64_t +dri2XcbSwapBuffers(Display *dpy, + __GLXDRIdrawable *pdraw, + int64_t target_msc, + int64_t divisor, + int64_t remainder) +{ + xcb_dri2_swap_buffers_cookie_t swap_buffers_cookie; + xcb_dri2_swap_buffers_reply_t *swap_buffers_reply; + uint32_t target_msc_hi, target_msc_lo; + uint32_t divisor_hi, divisor_lo; + uint32_t remainder_hi, remainder_lo; + int64_t ret = 0; + xcb_connection_t *c = XGetXCBConnection(dpy); + + split_counter(target_msc, &target_msc_hi, &target_msc_lo); + split_counter(divisor, &divisor_hi, &divisor_lo); + split_counter(remainder, &remainder_hi, &remainder_lo); + + swap_buffers_cookie = + xcb_dri2_swap_buffers_unchecked(c, pdraw->xDrawable, + target_msc_hi, target_msc_lo, + divisor_hi, divisor_lo, + remainder_hi, remainder_lo); + + /* Immediately wait on the swapbuffers reply. If we didn't, we'd have + * to do so some time before reusing a (non-pageflipped) backbuffer. + * Otherwise, the new rendering could get ahead of the X Server's + * dispatch of the swapbuffer and you'd display garbage. + * + * We use XSync() first to reap the invalidate events through the event + * filter, to ensure that the next drawing doesn't use an invalidated + * buffer. + */ + XSync(dpy, False); + + swap_buffers_reply = + xcb_dri2_swap_buffers_reply(c, swap_buffers_cookie, NULL); + if (swap_buffers_reply) { + ret = merge_counter(swap_buffers_reply->swap_hi, + swap_buffers_reply->swap_lo); + free(swap_buffers_reply); + } + return ret; +} + static int64_t dri2SwapBuffers(__GLXDRIdrawable *pdraw, int64_t target_msc, int64_t divisor, - int64_t remainder) + int64_t remainder, Bool flush) { - __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw; - __GLXdisplayPrivate *dpyPriv = __glXInitialize(priv->base.psc->dpy); - __GLXDRIdisplayPrivate *pdp = - (__GLXDRIdisplayPrivate *)dpyPriv->dri2Display; - int64_t ret; - -#ifdef __DRI2_FLUSH - if (pdraw->psc->f) - (*pdraw->psc->f->flush)(pdraw->driDrawable); -#endif + struct dri2_drawable *priv = (struct dri2_drawable *) pdraw; + struct glx_display *dpyPriv = __glXInitialize(priv->base.psc->dpy); + struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc; + struct dri2_display *pdp = + (struct dri2_display *)dpyPriv->dri2Display; + int64_t ret = 0; - /* Old servers don't send invalidate events */ - if (!pdp->invalidateAvailable) - dri2InvalidateBuffers(dpyPriv->dpy, pdraw->drawable); + /* Check we have the right attachments */ + if (!priv->have_back) + return ret; /* Old servers can't handle swapbuffers */ if (!pdp->swapAvailable) { - dri2CopySubBuffer(pdraw, 0, 0, priv->width, priv->height); - return 0; + __dri2CopySubBuffer(pdraw, 0, 0, priv->width, priv->height, + __DRI2_THROTTLE_SWAPBUFFER, flush); + } else { + __DRIcontext *ctx = dri2GetCurrentContext(); + unsigned flags = __DRI2_FLUSH_DRAWABLE; + if (flush) + flags |= __DRI2_FLUSH_CONTEXT; + dri2Flush(psc, ctx, priv, flags, __DRI2_THROTTLE_SWAPBUFFER); + + ret = dri2XcbSwapBuffers(pdraw->psc->dpy, pdraw, + target_msc, divisor, remainder); + } + + if (psc->show_fps_interval) { + show_fps(priv); } -#ifdef X_DRI2SwapBuffers - DRI2SwapBuffers(pdraw->psc->dpy, pdraw->xDrawable, target_msc, divisor, - remainder, &ret); -#endif + /* Old servers don't send invalidate events */ + if (!pdp->invalidateAvailable) + dri2InvalidateBuffers(dpyPriv->dpy, pdraw->xDrawable); return ret; } @@ -416,7 +871,7 @@ dri2GetBuffers(__DRIdrawable * driDrawable, unsigned int *attachments, int count, int *out_count, void *loaderPrivate) { - __GLXDRIdrawablePrivate *pdraw = loaderPrivate; + struct dri2_drawable *pdraw = loaderPrivate; DRI2Buffer *buffers; buffers = DRI2GetBuffers(pdraw->base.psc->dpy, pdraw->base.xDrawable, @@ -428,7 +883,7 @@ dri2GetBuffers(__DRIdrawable * driDrawable, pdraw->height = *height; process_buffers(pdraw, buffers, *out_count); - Xfree(buffers); + free(buffers); return pdraw->buffers; } @@ -439,7 +894,7 @@ dri2GetBuffersWithFormat(__DRIdrawable * driDrawable, unsigned int *attachments, int count, int *out_count, void *loaderPrivate) { - __GLXDRIdrawablePrivate *pdraw = loaderPrivate; + struct dri2_drawable *pdraw = loaderPrivate; DRI2Buffer *buffers; buffers = DRI2GetBuffersWithFormat(pdraw->base.psc->dpy, @@ -453,103 +908,359 @@ dri2GetBuffersWithFormat(__DRIdrawable * driDrawable, pdraw->height = *height; process_buffers(pdraw, buffers, *out_count); - Xfree(buffers); + free(buffers); return pdraw->buffers; } -#ifdef X_DRI2SwapInterval - -static void +static int dri2SetSwapInterval(__GLXDRIdrawable *pdraw, int interval) { - __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw; + xcb_connection_t *c = XGetXCBConnection(pdraw->psc->dpy); + struct dri2_drawable *priv = (struct dri2_drawable *) pdraw; + GLint vblank_mode = DRI_CONF_VBLANK_DEF_INTERVAL_1; + struct dri2_screen *psc = (struct dri2_screen *) priv->base.psc; + + if (psc->config) + psc->config->configQueryi(psc->driScreen, + "vblank_mode", &vblank_mode); + + switch (vblank_mode) { + case DRI_CONF_VBLANK_NEVER: + if (interval != 0) + return GLX_BAD_VALUE; + break; + case DRI_CONF_VBLANK_ALWAYS_SYNC: + if (interval <= 0) + return GLX_BAD_VALUE; + break; + default: + break; + } - DRI2SwapInterval(priv->base.psc->dpy, pdraw->xDrawable, interval); + xcb_dri2_swap_interval(c, priv->base.xDrawable, interval); priv->swap_interval = interval; + + return 0; } -static unsigned int +static int dri2GetSwapInterval(__GLXDRIdrawable *pdraw) { - __GLXDRIdrawablePrivate *priv = (__GLXDRIdrawablePrivate *) pdraw; + struct dri2_drawable *priv = (struct dri2_drawable *) pdraw; return priv->swap_interval; } -#endif /* X_DRI2SwapInterval */ +static void +driSetBackgroundContext(void *loaderPrivate) +{ + struct dri2_context *pcp = (struct dri2_context *) loaderPrivate; + __glXSetCurrentContext(&pcp->base); +} + +static GLboolean +driIsThreadSafe(void *loaderPrivate) +{ + struct dri2_context *pcp = (struct dri2_context *) loaderPrivate; + /* Check Xlib is running in thread safe mode + * + * 'lock_fns' is the XLockDisplay function pointer of the X11 display 'dpy'. + * It wll be NULL if XInitThreads wasn't called. + */ + return pcp->base.psc->dpy->lock_fns != NULL; +} static const __DRIdri2LoaderExtension dri2LoaderExtension = { - {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION}, - dri2GetBuffers, - dri2FlushFrontBuffer, - dri2GetBuffersWithFormat, + .base = { __DRI_DRI2_LOADER, 3 }, + + .getBuffers = dri2GetBuffers, + .flushFrontBuffer = dri2FlushFrontBuffer, + .getBuffersWithFormat = dri2GetBuffersWithFormat, }; static const __DRIdri2LoaderExtension dri2LoaderExtension_old = { - {__DRI_DRI2_LOADER, __DRI_DRI2_LOADER_VERSION}, - dri2GetBuffers, - dri2FlushFrontBuffer, - NULL, + .base = { __DRI_DRI2_LOADER, 3 }, + + .getBuffers = dri2GetBuffers, + .flushFrontBuffer = dri2FlushFrontBuffer, + .getBuffersWithFormat = NULL, }; -static const __DRIextension *loader_extensions[] = { - &dri2LoaderExtension.base, - &systemTimeExtension.base, - NULL +static const __DRIuseInvalidateExtension dri2UseInvalidate = { + .base = { __DRI_USE_INVALIDATE, 1 } }; -static const __DRIextension *loader_extensions_old[] = { - &dri2LoaderExtension_old.base, - &systemTimeExtension.base, - NULL +static const __DRIbackgroundCallableExtension driBackgroundCallable = { + .base = { __DRI_BACKGROUND_CALLABLE, 2 }, + + .setBackgroundContext = driSetBackgroundContext, + .isThreadSafe = driIsThreadSafe, }; _X_HIDDEN void dri2InvalidateBuffers(Display *dpy, XID drawable) { - __GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, NULL); + __GLXDRIdrawable *pdraw = + dri2GetGlxDrawableFromXDrawableId(dpy, drawable); + struct dri2_screen *psc; + struct dri2_drawable *pdp = (struct dri2_drawable *) pdraw; + + if (!pdraw) + return; + + psc = (struct dri2_screen *) pdraw->psc; + + if (pdraw && psc->f && psc->f->base.version >= 3 && psc->f->invalidate) + psc->f->invalidate(pdp->driDrawable); +} + +static void +dri2_bind_tex_image(Display * dpy, + GLXDrawable drawable, + int buffer, const int *attrib_list) +{ + struct glx_context *gc = __glXGetCurrentContext(); + struct dri2_context *pcp = (struct dri2_context *) gc; + __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable); + struct glx_display *dpyPriv = __glXInitialize(dpy); + struct dri2_drawable *pdraw = (struct dri2_drawable *) base; + struct dri2_display *pdp; + struct dri2_screen *psc; + + if (dpyPriv == NULL) + return; + + pdp = (struct dri2_display *) dpyPriv->dri2Display; + + if (pdraw != NULL) { + psc = (struct dri2_screen *) base->psc; + + if (!pdp->invalidateAvailable && psc->f && + psc->f->base.version >= 3 && psc->f->invalidate) + psc->f->invalidate(pdraw->driDrawable); + + if (psc->texBuffer->base.version >= 2 && + psc->texBuffer->setTexBuffer2 != NULL) { + (*psc->texBuffer->setTexBuffer2) (pcp->driContext, + pdraw->base.textureTarget, + pdraw->base.textureFormat, + pdraw->driDrawable); + } + else { + (*psc->texBuffer->setTexBuffer) (pcp->driContext, + pdraw->base.textureTarget, + pdraw->driDrawable); + } + } +} + +static void +dri2_release_tex_image(Display * dpy, GLXDrawable drawable, int buffer) +{ + struct glx_context *gc = __glXGetCurrentContext(); + struct dri2_context *pcp = (struct dri2_context *) gc; + __GLXDRIdrawable *base = GetGLXDRIDrawable(dpy, drawable); + struct glx_display *dpyPriv = __glXInitialize(dpy); + struct dri2_drawable *pdraw = (struct dri2_drawable *) base; + struct dri2_screen *psc; + + if (dpyPriv != NULL && pdraw != NULL) { + psc = (struct dri2_screen *) base->psc; + + if (psc->texBuffer->base.version >= 3 && + psc->texBuffer->releaseTexBuffer != NULL) { + (*psc->texBuffer->releaseTexBuffer) (pcp->driContext, + pdraw->base.textureTarget, + pdraw->driDrawable); + } + } +} + +static const struct glx_context_vtable dri2_context_vtable = { + .destroy = dri2_destroy_context, + .bind = dri2_bind_context, + .unbind = dri2_unbind_context, + .wait_gl = dri2_wait_gl, + .wait_x = dri2_wait_x, + .use_x_font = DRI_glXUseXFont, + .bind_tex_image = dri2_bind_tex_image, + .release_tex_image = dri2_release_tex_image, + .get_proc_address = NULL, + .interop_query_device_info = dri2_interop_query_device_info, + .interop_export_object = dri2_interop_export_object +}; + +static void +dri2BindExtensions(struct dri2_screen *psc, struct glx_display * priv, + const char *driverName) +{ + const struct dri2_display *const pdp = (struct dri2_display *) + priv->dri2Display; + const __DRIextension **extensions; + int i; + + extensions = psc->core->getExtensions(psc->driScreen); + + __glXEnableDirectExtension(&psc->base, "GLX_SGI_swap_control"); + __glXEnableDirectExtension(&psc->base, "GLX_MESA_swap_control"); + __glXEnableDirectExtension(&psc->base, "GLX_SGI_make_current_read"); -#if __DRI2_FLUSH_VERSION >= 3 - if (pdraw && pdraw->psc->f) - pdraw->psc->f->invalidate(pdraw->driDrawable); -#endif + /* + * GLX_INTEL_swap_event is broken on the server side, where it's + * currently unconditionally enabled. This completely breaks + * systems running on drivers which don't support that extension. + * There's no way to test for its presence on this side, so instead + * of disabling it unconditionally, just disable it for drivers + * which are known to not support it, or for DDX drivers supporting + * only an older (pre-ScheduleSwap) version of DRI2. + * + * This is a hack which is required until: + * http://lists.x.org/archives/xorg-devel/2013-February/035449.html + * is merged and updated xserver makes it's way into distros: + */ + if (pdp->swapAvailable && strcmp(driverName, "vmwgfx") != 0) { + __glXEnableDirectExtension(&psc->base, "GLX_INTEL_swap_event"); + } + + if (psc->dri2->base.version >= 3) { + const unsigned mask = psc->dri2->getAPIMask(psc->driScreen); + + __glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context"); + __glXEnableDirectExtension(&psc->base, "GLX_ARB_create_context_profile"); + + if ((mask & ((1 << __DRI_API_GLES) | + (1 << __DRI_API_GLES2) | + (1 << __DRI_API_GLES3))) != 0) { + __glXEnableDirectExtension(&psc->base, + "GLX_EXT_create_context_es_profile"); + __glXEnableDirectExtension(&psc->base, + "GLX_EXT_create_context_es2_profile"); + } + } + + for (i = 0; extensions[i]; i++) { + if ((strcmp(extensions[i]->name, __DRI_TEX_BUFFER) == 0)) { + psc->texBuffer = (__DRItexBufferExtension *) extensions[i]; + __glXEnableDirectExtension(&psc->base, "GLX_EXT_texture_from_pixmap"); + } + + if ((strcmp(extensions[i]->name, __DRI2_FLUSH) == 0)) { + psc->f = (__DRI2flushExtension *) extensions[i]; + /* internal driver extension, no GL extension exposed */ + } + + if ((strcmp(extensions[i]->name, __DRI2_CONFIG_QUERY) == 0)) + psc->config = (__DRI2configQueryExtension *) extensions[i]; + + if (((strcmp(extensions[i]->name, __DRI2_THROTTLE) == 0))) + psc->throttle = (__DRI2throttleExtension *) extensions[i]; + + /* DRI2 version 3 is also required because + * GLX_ARB_create_context_robustness requires GLX_ARB_create_context. + */ + if (psc->dri2->base.version >= 3 + && strcmp(extensions[i]->name, __DRI2_ROBUSTNESS) == 0) + __glXEnableDirectExtension(&psc->base, + "GLX_ARB_create_context_robustness"); + + /* DRI2 version 3 is also required because GLX_MESA_query_renderer + * requires GLX_ARB_create_context_profile. + */ + if (psc->dri2->base.version >= 3 + && strcmp(extensions[i]->name, __DRI2_RENDERER_QUERY) == 0) { + psc->rendererQuery = (__DRI2rendererQueryExtension *) extensions[i]; + __glXEnableDirectExtension(&psc->base, "GLX_MESA_query_renderer"); + } + + if (strcmp(extensions[i]->name, __DRI2_INTEROP) == 0) + psc->interop = (__DRI2interopExtension*)extensions[i]; + + /* DRI2 version 3 is also required because + * GLX_ARB_control_flush_control requires GLX_ARB_create_context. + */ + if (psc->dri2->base.version >= 3 + && strcmp(extensions[i]->name, __DRI2_FLUSH_CONTROL) == 0) + __glXEnableDirectExtension(&psc->base, + "GLX_ARB_context_flush_control"); + } } -static __GLXDRIscreen * -dri2CreateScreen(__GLXscreenConfigs * psc, int screen, - __GLXdisplayPrivate * priv) +static const struct glx_screen_vtable dri2_screen_vtable = { + .create_context = dri2_create_context, + .create_context_attribs = dri2_create_context_attribs, + .query_renderer_integer = dri2_query_renderer_integer, + .query_renderer_string = dri2_query_renderer_string, +}; + +static struct glx_screen * +dri2CreateScreen(int screen, struct glx_display * priv) { const __DRIconfig **driver_configs; const __DRIextension **extensions; - const __GLXDRIdisplayPrivate *const pdp = (__GLXDRIdisplayPrivate *) + const struct dri2_display *const pdp = (struct dri2_display *) priv->dri2Display; + struct dri2_screen *psc; __GLXDRIscreen *psp; - char *driverName, *deviceName; + struct glx_config *configs = NULL, *visuals = NULL; + char *driverName = NULL, *loader_driverName, *deviceName, *tmp; drm_magic_t magic; int i; + unsigned char disable; - psp = Xmalloc(sizeof *psp); - if (psp == NULL) + psc = calloc(1, sizeof *psc); + if (psc == NULL) return NULL; - if (!DRI2Connect(psc->dpy, RootWindow(psc->dpy, screen), + psc->fd = -1; + + if (!glx_screen_init(&psc->base, screen, priv)) { + free(psc); + return NULL; + } + + if (!DRI2Connect(priv->dpy, RootWindow(priv->dpy, screen), &driverName, &deviceName)) { - XFree(psp); + glx_screen_cleanup(&psc->base); + free(psc); + InfoMessageF("screen %d does not appear to be DRI2 capable\n", screen); return NULL; } + psc->fd = loader_open_device(deviceName); + if (psc->fd < 0) { + ErrorMessageF("failed to open drm device: %s\n", strerror(errno)); + goto handle_error; + } + + if (drmGetMagic(psc->fd, &magic)) { + ErrorMessageF("failed to get magic\n"); + goto handle_error; + } + + if (!DRI2Authenticate(priv->dpy, RootWindow(priv->dpy, screen), magic)) { + ErrorMessageF("failed to authenticate magic %d\n", magic); + goto handle_error; + } + + /* If Mesa knows about the appropriate driver for this fd, then trust it. + * Otherwise, default to the server's value. + */ + loader_driverName = loader_get_driver_for_fd(psc->fd); + if (loader_driverName) { + free(driverName); + driverName = loader_driverName; + } + psc->driver = driOpenDriver(driverName); if (psc->driver == NULL) { ErrorMessageF("driver pointer missing\n"); goto handle_error; } - extensions = dlsym(psc->driver, __DRI_DRIVER_EXTENSIONS); - if (extensions == NULL) { - ErrorMessageF("driver exports no extensions (%s)\n", dlerror()); + extensions = driGetDriverExtensions(psc->driver, driverName); + if (extensions == NULL) goto handle_error; - } for (i = 0; extensions[i]; i++) { if (strcmp(extensions[i]->name, __DRI_CORE) == 0) @@ -563,89 +1274,109 @@ dri2CreateScreen(__GLXscreenConfigs * psc, int screen, goto handle_error; } - psc->fd = open(deviceName, O_RDWR); - if (psc->fd < 0) { - ErrorMessageF("failed to open drm device: %s\n", strerror(errno)); - goto handle_error; + if (psc->dri2->base.version >= 4) { + psc->driScreen = + psc->dri2->createNewScreen2(screen, psc->fd, + (const __DRIextension **) + &pdp->loader_extensions[0], + extensions, + &driver_configs, psc); + } else { + psc->driScreen = + psc->dri2->createNewScreen(screen, psc->fd, + (const __DRIextension **) + &pdp->loader_extensions[0], + &driver_configs, psc); } - if (drmGetMagic(psc->fd, &magic)) { - ErrorMessageF("failed to get magic\n"); + if (psc->driScreen == NULL) { + ErrorMessageF("failed to create dri screen\n"); goto handle_error; } - if (!DRI2Authenticate(psc->dpy, RootWindow(psc->dpy, screen), magic)) { - ErrorMessageF("failed to authenticate magic %d\n", magic); - goto handle_error; - } + dri2BindExtensions(psc, priv, driverName); - /* If the server does not support the protocol for - * DRI2GetBuffersWithFormat, don't supply that interface to the driver. - */ - psc->__driScreen = - psc->dri2->createNewScreen(screen, psc->fd, ((pdp->driMinor < 1) - ? loader_extensions_old - : loader_extensions), - &driver_configs, psc); + configs = driConvertConfigs(psc->core, psc->base.configs, driver_configs); + visuals = driConvertConfigs(psc->core, psc->base.visuals, driver_configs); - if (psc->__driScreen == NULL) { - ErrorMessageF("failed to create dri screen\n"); - goto handle_error; + if (!configs || !visuals) { + ErrorMessageF("No matching fbConfigs or visuals found\n"); + goto handle_error; } - driBindCommonExtensions(psc); - dri2BindExtensions(psc); - - psc->configs = driConvertConfigs(psc->core, psc->configs, driver_configs); - psc->visuals = driConvertConfigs(psc->core, psc->visuals, driver_configs); + glx_config_destroy_list(psc->base.configs); + psc->base.configs = configs; + glx_config_destroy_list(psc->base.visuals); + psc->base.visuals = visuals; psc->driver_configs = driver_configs; + psc->base.vtable = &dri2_screen_vtable; + psp = &psc->vtable; + psc->base.driScreen = psp; psp->destroyScreen = dri2DestroyScreen; - psp->createContext = dri2CreateContext; psp->createDrawable = dri2CreateDrawable; psp->swapBuffers = dri2SwapBuffers; - psp->waitGL = dri2WaitGL; - psp->waitX = dri2WaitX; psp->getDrawableMSC = NULL; psp->waitForMSC = NULL; psp->waitForSBC = NULL; psp->setSwapInterval = NULL; psp->getSwapInterval = NULL; + psp->getBufferAge = NULL; if (pdp->driMinor >= 2) { -#ifdef X_DRI2GetMSC psp->getDrawableMSC = dri2DrawableGetMSC; -#endif -#ifdef X_DRI2WaitMSC psp->waitForMSC = dri2WaitForMSC; psp->waitForSBC = dri2WaitForSBC; -#endif -#ifdef X_DRI2SwapInterval psp->setSwapInterval = dri2SetSwapInterval; psp->getSwapInterval = dri2GetSwapInterval; -#endif -#if defined(X_DRI2GetMSC) && defined(X_DRI2WaitMSC) && defined(X_DRI2SwapInterval) - __glXEnableDirectExtension(psc, "GLX_OML_sync_control"); -#endif + if (psc->config->configQueryb(psc->driScreen, + "glx_disable_oml_sync_control", + &disable) || !disable) + __glXEnableDirectExtension(&psc->base, "GLX_OML_sync_control"); } - /* DRI2 suports SubBuffer through DRI2CopyRegion, so it's always + if (psc->config->configQueryb(psc->driScreen, + "glx_disable_sgi_video_sync", + &disable) || !disable) + __glXEnableDirectExtension(&psc->base, "GLX_SGI_video_sync"); + + /* DRI2 supports SubBuffer through DRI2CopyRegion, so it's always * available.*/ psp->copySubBuffer = dri2CopySubBuffer; - __glXEnableDirectExtension(psc, "GLX_MESA_copy_sub_buffer"); + __glXEnableDirectExtension(&psc->base, "GLX_MESA_copy_sub_buffer"); - Xfree(driverName); - Xfree(deviceName); + free(driverName); + free(deviceName); - return psp; + tmp = getenv("LIBGL_SHOW_FPS"); + psc->show_fps_interval = (tmp) ? atoi(tmp) : 0; + if (psc->show_fps_interval < 0) + psc->show_fps_interval = 0; -handle_error: - Xfree(driverName); - Xfree(deviceName); - XFree(psp); + InfoMessageF("Using DRI2 for screen %d\n", screen); + + return &psc->base; - /* FIXME: clean up here */ +handle_error: + CriticalErrorMessageF("failed to load driver: %s\n", driverName); + + if (configs) + glx_config_destroy_list(configs); + if (visuals) + glx_config_destroy_list(visuals); + if (psc->driScreen) + psc->core->destroyScreen(psc->driScreen); + psc->driScreen = NULL; + if (psc->fd >= 0) + close(psc->fd); + if (psc->driver) + dlclose(psc->driver); + + free(driverName); + free(deviceName); + glx_screen_cleanup(&psc->base); + free(psc); return NULL; } @@ -655,7 +1386,23 @@ handle_error: static void dri2DestroyDisplay(__GLXDRIdisplay * dpy) { - Xfree(dpy); + struct dri2_display *pdp = (struct dri2_display *) dpy; + + __glxHashDestroy(pdp->dri2Hash); + free(dpy); +} + +_X_HIDDEN __GLXDRIdrawable * +dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id) +{ + struct glx_display *d = __glXInitialize(dpy); + struct dri2_display *pdp = (struct dri2_display *) d->dri2Display; + __GLXDRIdrawable *pdraw; + + if (__glxHashLookup(pdp->dri2Hash, id, (void *) &pdraw) == 0) + return pdraw; + + return NULL; } /* @@ -666,18 +1413,18 @@ dri2DestroyDisplay(__GLXDRIdisplay * dpy) _X_HIDDEN __GLXDRIdisplay * dri2CreateDisplay(Display * dpy) { - __GLXDRIdisplayPrivate *pdp; - int eventBase, errorBase; + struct dri2_display *pdp; + int eventBase, errorBase, i; if (!DRI2QueryExtension(dpy, &eventBase, &errorBase)) return NULL; - pdp = Xmalloc(sizeof *pdp); + pdp = malloc(sizeof *pdp); if (pdp == NULL) return NULL; if (!DRI2QueryVersion(dpy, &pdp->driMajor, &pdp->driMinor)) { - Xfree(pdp); + free(pdp); return NULL; } @@ -688,6 +1435,24 @@ dri2CreateDisplay(Display * dpy) pdp->base.destroyDisplay = dri2DestroyDisplay; pdp->base.createScreen = dri2CreateScreen; + i = 0; + if (pdp->driMinor < 1) + pdp->loader_extensions[i++] = &dri2LoaderExtension_old.base; + else + pdp->loader_extensions[i++] = &dri2LoaderExtension.base; + + pdp->loader_extensions[i++] = &dri2UseInvalidate.base; + + pdp->loader_extensions[i++] = &driBackgroundCallable.base; + + pdp->loader_extensions[i++] = NULL; + + pdp->dri2Hash = __glxHashCreate(); + if (pdp->dri2Hash == NULL) { + free(pdp); + return NULL; + } + return &pdp->base; }