Revert "Only build when BOARD_USE_MESA is true"

[android-x86/external-mesa.git] / src / glx / glxext.c

diff --git a/src/glx/glxext.c b/src/glx/glxext.c
index 8254544..ef1e7ad 100644 (file)
--- a/src/glx/glxext.c
+++ b/src/glx/glxext.c
@@ -47,11 +47,9 @@
 #endif
 #include "glxextensions.h"
 
-#ifdef USE_XCB
 #include <X11/Xlib-xcb.h>
 #include <xcb/xcb.h>
 #include <xcb/glx.h>
-#endif
 
 
 #ifdef DEBUG
@@ -83,6 +81,7 @@ static /* const */ char *error_list[] = {
    "GLXBadPbuffer",
    "GLXBadCurrentDrawable",
    "GLXBadWindow",
+   "GLXBadProfileARB",
 };
 
 #ifdef GLX_USE_APPLEGL
@@ -208,13 +207,13 @@ FreeScreenConfigs(struct glx_display * priv)
       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;
 }
 
@@ -230,10 +229,8 @@ 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);
 
@@ -254,7 +251,7 @@ glx_display_free(struct glx_display *priv)
    priv->dri2Display = NULL;
 #endif
 
-   Xfree((char *) priv);
+   free((char *) priv);
 }
 
 static int
@@ -284,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
@@ -293,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;
@@ -301,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 */
 }
 
 /* 
@@ -401,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
@@ -611,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;
@@ -635,7 +610,7 @@ createConfigsFromProperties(Display * dpy, int nvisuals, int nprops,
    }
 
    if (props != buf)
-      Xfree(props);
+      free(props);
 
    return modes;
 }
@@ -737,15 +712,14 @@ glx_screen_cleanup(struct glx_screen *psc)
 {
    if (psc->configs) {
       glx_config_destroy_list(psc->configs);
-      if (psc->effectiveGLXexts)
-          Xfree(psc->effectiveGLXexts);
+      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 */
    }
-   Xfree((char *) psc->serverGLXexts);
+   free((char *) psc->serverGLXexts);
 }
 
 /*
@@ -762,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;
 
@@ -820,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;
    }
@@ -836,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;
    }
@@ -875,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. */
@@ -957,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 */
@@ -1009,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 */
 }