#endif
#include "glxextensions.h"
-#ifdef USE_XCB
#include <X11/Xlib-xcb.h>
#include <xcb/xcb.h>
#include <xcb/glx.h>
-#endif
#ifdef DEBUG
"GLXBadPbuffer",
"GLXBadCurrentDrawable",
"GLXBadWindow",
+ "GLXBadProfileARB",
};
#ifdef 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;
}
}
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);
priv->dri2Display = NULL;
#endif
- Xfree((char *) priv);
+ free((char *) priv);
}
static int
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
*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 */
}
/*
#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
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;
}
if (props != buf)
- Xfree(props);
+ free(props);
return modes;
}
{
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);
}
/*
** 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;
/* 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;
}
if (!QueryVersion(dpy, dpyPriv->majorOpcode,
&dpyPriv->majorVersion, &dpyPriv->minorVersion)
|| (dpyPriv->majorVersion == 1 && dpyPriv->minorVersion < 1)) {
- Xfree(dpyPriv);
+ free(dpyPriv);
_XUnlockMutex(_Xglobal_lock);
return NULL;
}
#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;
}
-#ifdef USE_XCB
__glX_send_client_info(dpyPriv);
-#else
- __glXClientInfo(dpy, dpyPriv->majorOpcode);
-#endif
/* Grab the lock again and add the dispay private, unless somebody
* beat us to initializing on this display in the meantime. */
__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 */
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 */
}