X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglx%2Fglxext.c;h=ef1e7ad2c8bdda2331930cb17548fdc1302c8984;hb=b1390c7992c457f230cb5a7a64803b194de316e0;hp=7ba4666187ac1d2bd296566aa6f3f7cdcc3a6bd0;hpb=ae9487c29984addc96a6d617292370fbc3f8ff9a;p=mesa.git diff --git a/src/glx/glxext.c b/src/glx/glxext.c index 7ba4666187a..ef1e7ad2c8b 100644 --- a/src/glx/glxext.c +++ b/src/glx/glxext.c @@ -41,18 +41,15 @@ #include "glxclient.h" #include #include -#include #ifdef GLX_USE_APPLEGL #include "apple_glx.h" #include "apple_visual.h" #endif #include "glxextensions.h" -#ifdef USE_XCB #include #include #include -#endif #ifdef DEBUG @@ -84,6 +81,7 @@ static /* const */ char *error_list[] = { "GLXBadPbuffer", "GLXBadCurrentDrawable", "GLXBadWindow", + "GLXBadProfileARB", }; #ifdef GLX_USE_APPLEGL @@ -131,28 +129,25 @@ __glXWireToEvent(Display *dpy, XEvent *event, xEvent *wire) aevent->count = awire->count; return True; } - /* No easy symbol to test for this, as GLX_BufferSwapComplete is - * defined in the local glx.h header, but the - * xGLXBufferSwapComplete typedef is only available in new versions - * of the external glxproto.h header, which doesn't have any - * testable versioning define. - * - * I'll use the related DRI2 define, in the hope that we won't - * receive these events unless we know how to ask for them: - */ -#ifdef X_DRI2SwapBuffers case GLX_BufferSwapComplete: { GLXBufferSwapComplete *aevent = (GLXBufferSwapComplete *)event; - xGLXBufferSwapComplete *awire = (xGLXBufferSwapComplete *)wire; + xGLXBufferSwapComplete2 *awire = (xGLXBufferSwapComplete2 *)wire; + struct glx_drawable *glxDraw = GetGLXDrawable(dpy, awire->drawable); aevent->event_type = awire->event_type; aevent->drawable = awire->drawable; aevent->ust = ((CARD64)awire->ust_hi << 32) | awire->ust_lo; aevent->msc = ((CARD64)awire->msc_hi << 32) | awire->msc_lo; - aevent->sbc = ((CARD64)awire->sbc_hi << 32) | awire->sbc_lo; + + if (!glxDraw) + return False; + + if (awire->sbc < glxDraw->lastEventSbc) + glxDraw->eventSbcWrap += 0x100000000; + glxDraw->lastEventSbc = awire->sbc; + aevent->sbc = awire->sbc + glxDraw->eventSbcWrap; return True; } -#endif default: /* client doesn't support server event */ break; @@ -206,29 +201,19 @@ FreeScreenConfigs(struct glx_display * priv) screens = ScreenCount(priv->dpy); for (i = 0; i < screens; i++) { psc = priv->screens[i]; - if (psc->configs) { - glx_config_destroy_list(psc->configs); - if (psc->effectiveGLXexts) - Xfree(psc->effectiveGLXexts); - psc->configs = NULL; /* NOTE: just for paranoia */ - } - if (psc->visuals) { - glx_config_destroy_list(psc->visuals); - psc->visuals = NULL; /* NOTE: just for paranoia */ - } - Xfree((char *) psc->serverGLXexts); + glx_screen_cleanup(psc); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) if (psc->driScreen) { psc->driScreen->destroyScreen(psc); } else { - Xfree(psc); + free(psc); } #else - Xfree(psc); + free(psc); #endif } - XFree((char *) priv->screens); + free((char *) priv->screens); priv->screens = NULL; } @@ -244,10 +229,10 @@ glx_display_free(struct glx_display *priv) } FreeScreenConfigs(priv); - if (priv->serverGLXvendor) - Xfree((char *) priv->serverGLXvendor); - if (priv->serverGLXversion) - Xfree((char *) priv->serverGLXversion); + free((char *) priv->serverGLXvendor); + free((char *) priv->serverGLXversion); + + __glxHashDestroy(priv->glXDrawHash); #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) __glxHashDestroy(priv->drawHash); @@ -266,7 +251,7 @@ glx_display_free(struct glx_display *priv) priv->dri2Display = NULL; #endif - Xfree((char *) priv); + free((char *) priv); } static int @@ -278,7 +263,7 @@ __glXCloseDisplay(Display * dpy, XExtCodes * codes) prev = &glx_displays; for (priv = glx_displays; priv; prev = &priv->next, priv = priv->next) { if (priv->dpy == dpy) { - (*prev) = priv->next; + *prev = priv->next; break; } } @@ -296,7 +281,6 @@ __glXCloseDisplay(Display * dpy, XExtCodes * codes) static Bool QueryVersion(Display * dpy, int opcode, int *major, int *minor) { -#ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); xcb_glx_query_version_reply_t *reply = xcb_glx_query_version_reply(c, xcb_glx_query_version @@ -305,6 +289,9 @@ QueryVersion(Display * dpy, int opcode, int *major, int *minor) GLX_MINOR_VERSION), NULL); + if (!reply) + return GL_FALSE; + if (reply->major_version != GLX_MAJOR_VERSION) { free(reply); return GL_FALSE; @@ -313,32 +300,6 @@ QueryVersion(Display * dpy, int opcode, int *major, int *minor) *minor = min(reply->minor_version, GLX_MINOR_VERSION); free(reply); return GL_TRUE; -#else - xGLXQueryVersionReq *req; - xGLXQueryVersionReply reply; - - /* Send the glXQueryVersion request */ - LockDisplay(dpy); - GetReq(GLXQueryVersion, req); - req->reqType = opcode; - req->glxCode = X_GLXQueryVersion; - req->majorVersion = GLX_MAJOR_VERSION; - req->minorVersion = GLX_MINOR_VERSION; - _XReply(dpy, (xReply *) & reply, 0, False); - UnlockDisplay(dpy); - SyncHandle(); - - if (reply.majorVersion != GLX_MAJOR_VERSION) { - /* - ** The server does not support the same major release as this - ** client. - */ - return GL_FALSE; - } - *major = reply.majorVersion; - *minor = min(reply.minorVersion, GLX_MINOR_VERSION); - return GL_TRUE; -#endif /* USE_XCB */ } /* @@ -413,6 +374,8 @@ __glXInitializeVisualConfigFromTags(struct glx_config * config, int count, #endif } + config->sRGBCapable = GL_FALSE; + /* ** Additional properties may be in a list at the end ** of the reply. They are in pairs of property type @@ -568,6 +531,10 @@ __glXInitializeVisualConfigFromTags(struct glx_config * config, int count, config->yInverted = *bp++; break; #endif + case GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT: + config->sRGBCapable = *bp++; + break; + case GLX_USE_GL: if (fbconfig_style_tags) bp++; @@ -619,7 +586,7 @@ createConfigsFromProperties(Display * dpy, int nvisuals, int nprops, if (prop_size <= sizeof(buf)) props = buf; else - props = Xmalloc(prop_size); + props = malloc(prop_size); /* Read each config structure and convert it into our format */ m = modes; @@ -643,7 +610,7 @@ createConfigsFromProperties(Display * dpy, int nvisuals, int nprops, } if (props != buf) - Xfree(props); + free(props); return modes; } @@ -700,7 +667,7 @@ static GLboolean } else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) { GetReqExtra(GLXVendorPrivateWithReply, - sz_xGLXGetFBConfigsSGIXReq + + sz_xGLXGetFBConfigsSGIXReq - sz_xGLXVendorPrivateWithReplyReq, vpreq); sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq; sgi_req->reqType = priv->majorOpcode; @@ -740,6 +707,21 @@ glx_screen_init(struct glx_screen *psc, return GL_TRUE; } +_X_HIDDEN void +glx_screen_cleanup(struct glx_screen *psc) +{ + if (psc->configs) { + glx_config_destroy_list(psc->configs); + free(psc->effectiveGLXexts); + psc->configs = NULL; /* NOTE: just for paranoia */ + } + if (psc->visuals) { + glx_config_destroy_list(psc->visuals); + psc->visuals = NULL; /* NOTE: just for paranoia */ + } + free((char *) psc->serverGLXexts); +} + /* ** Allocate the memory for the per screen configs for each screen. ** If that works then fetch the per screen configs data. @@ -754,7 +736,7 @@ AllocAndFetchScreenConfigs(Display * dpy, struct glx_display * priv) ** First allocate memory for the array of per screen configs. */ screens = ScreenCount(dpy); - priv->screens = Xmalloc(screens * sizeof *priv->screens); + priv->screens = malloc(screens * sizeof *priv->screens); if (!priv->screens) return GL_FALSE; @@ -776,11 +758,12 @@ AllocAndFetchScreenConfigs(Display * dpy, struct glx_display * priv) psc = (*priv->driswDisplay->createScreen) (i, priv); #endif #if defined(GLX_USE_APPLEGL) - if (psc == NULL && priv->appleglDisplay) - psc = (*priv->appleglDisplay->createScreen) (i, priv); -#endif + if (psc == NULL) + psc = applegl_create_screen(i, priv); +#else if (psc == NULL) psc = indirect_create_screen(i, priv); +#endif priv->screens[i] = psc; } SyncHandle(); @@ -811,13 +794,13 @@ __glXInitialize(Display * dpy) /* Drop the lock while we create the display private. */ _XUnlockMutex(_Xglobal_lock); - dpyPriv = Xcalloc(1, sizeof *dpyPriv); + dpyPriv = calloc(1, sizeof *dpyPriv); if (!dpyPriv) return NULL; dpyPriv->codes = XInitExtension(dpy, __glXExtensionName); if (!dpyPriv->codes) { - Xfree(dpyPriv); + free(dpyPriv); _XUnlockMutex(_Xglobal_lock); return NULL; } @@ -827,10 +810,13 @@ __glXInitialize(Display * dpy) dpyPriv->serverGLXvendor = 0x0; dpyPriv->serverGLXversion = 0x0; - /* See if the versions are compatible */ + /* See if the versions are compatible. This GLX implementation does not + * work with servers that only support GLX 1.0. + */ if (!QueryVersion(dpy, dpyPriv->majorOpcode, - &dpyPriv->majorVersion, &dpyPriv->minorVersion)) { - Xfree(dpyPriv); + &dpyPriv->majorVersion, &dpyPriv->minorVersion) + || (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion < 1)) { + free(dpyPriv); _XUnlockMutex(_Xglobal_lock); return NULL; } @@ -843,6 +829,8 @@ __glXInitialize(Display * dpy) XESetCloseDisplay(dpy, dpyPriv->codes->extension, __glXCloseDisplay); XESetErrorString (dpy, dpyPriv->codes->extension,__glXErrorString); + dpyPriv->glXDrawHash = __glxHashCreate(); + #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL) glx_direct = (getenv("LIBGL_ALWAYS_INDIRECT") == NULL); glx_accel = (getenv("LIBGL_ALWAYS_SOFTWARE") == NULL); @@ -864,17 +852,16 @@ __glXInitialize(Display * dpy) #ifdef GLX_USE_APPLEGL if (!applegl_create_display(dpyPriv)) { - Xfree(dpyPriv); + free(dpyPriv); return NULL; } #endif if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) { - Xfree(dpyPriv); + free(dpyPriv); return NULL; } - if (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion >= 1) - __glXClientInfo(dpy, dpyPriv->majorOpcode); + __glX_send_client_info(dpyPriv); /* Grab the lock again and add the dispay private, unless somebody * beat us to initializing on this display in the meantime. */ @@ -946,29 +933,12 @@ _X_HIDDEN GLubyte * __glXFlushRenderBuffer(struct glx_context * ctx, GLubyte * pc) { Display *const dpy = ctx->currentDpy; -#ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); -#else - xGLXRenderReq *req; -#endif /* USE_XCB */ const GLint size = pc - ctx->buf; if ((dpy != NULL) && (size > 0)) { -#ifdef USE_XCB xcb_glx_render(c, ctx->currentContextTag, size, (const uint8_t *) ctx->buf); -#else - /* Send the entire buffer as an X request */ - LockDisplay(dpy); - GetReq(GLXRender, req); - req->reqType = ctx->majorOpcode; - req->glxCode = X_GLXRender; - req->contextTag = ctx->currentContextTag; - req->length += (size + 3) >> 2; - _XSend(dpy, (char *) ctx->buf, size); - UnlockDisplay(dpy); - SyncHandle(); -#endif } /* Reset pointer and return it */ @@ -998,32 +968,9 @@ __glXSendLargeChunk(struct glx_context * gc, GLint requestNumber, GLint totalRequests, const GLvoid * data, GLint dataLen) { Display *dpy = gc->currentDpy; -#ifdef USE_XCB xcb_connection_t *c = XGetXCBConnection(dpy); xcb_glx_render_large(c, gc->currentContextTag, requestNumber, totalRequests, dataLen, data); -#else - xGLXRenderLargeReq *req; - - if (requestNumber == 1) { - LockDisplay(dpy); - } - - GetReq(GLXRenderLarge, req); - req->reqType = gc->majorOpcode; - req->glxCode = X_GLXRenderLarge; - req->contextTag = gc->currentContextTag; - req->length += (dataLen + 3) >> 2; - req->requestNumber = requestNumber; - req->requestTotal = totalRequests; - req->dataBytes = dataLen; - Data(dpy, data, dataLen); - - if (requestNumber == totalRequests) { - UnlockDisplay(dpy); - SyncHandle(); - } -#endif /* USE_XCB */ }