XSetErrorHandler(oldXErrorHandler);
}
-extern __GLXDRIdrawable *GetGLXDRIDrawable(Display * dpy,
- GLXDrawable drawable,
- int *const scrn_num);
-
/**
* Get the __DRIdrawable for the drawable associated with a GLXContext
*
*/
static GLXContext
-CreateContext(Display * dpy, XVisualInfo * vis,
+CreateContext(Display * dpy, int generic_id,
const __GLcontextModes * const fbconfig,
GLXContext shareList,
- Bool allowDirect, GLXContextID contextID,
+ Bool allowDirect,
unsigned code, int renderType, int screen)
{
GLXContext gc;
#ifdef GLX_DIRECT_RENDERING
__GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
-#else
- (void) screen;
#endif
if (dpy == NULL)
return NULL;
+ if (generic_id == None)
+ return NULL;
+
gc = AllocateGLXContext(dpy);
if (!gc)
return NULL;
- if (None == contextID) {
- if ((vis == NULL) && (fbconfig == NULL))
- return NULL;
-
#ifdef GLX_DIRECT_RENDERING
- if (allowDirect && psc->driScreen) {
- const __GLcontextModes *mode;
-
- if (fbconfig == NULL) {
- mode = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
- if (mode == NULL) {
- xError error;
-
- error.errorCode = BadValue;
- error.resourceID = vis->visualid;
- error.sequenceNumber = dpy->request;
- error.type = X_Error;
- error.majorCode = gc->majorOpcode;
- error.minorCode = X_GLXCreateContext;
- _XError(dpy, &error);
- return None;
- }
- if (renderType == 0) {
- /* Initialize renderType now */
- renderType = mode->rgbMode ? GLX_RGBA_TYPE : GLX_COLOR_INDEX_TYPE;
- }
- }
- else {
- mode = fbconfig;
- }
-
- gc->driContext = psc->driScreen->createContext(psc, mode, gc,
- shareList,
- renderType);
- if (gc->driContext != NULL) {
- gc->screen = mode->screen;
- gc->psc = psc;
- gc->mode = mode;
- gc->isDirect = GL_TRUE;
- }
+ if (allowDirect && psc->driScreen) {
+ gc->driContext = psc->driScreen->createContext(psc, fbconfig, gc,
+ shareList, renderType);
+ if (gc->driContext != NULL) {
+ gc->screen = screen;
+ gc->psc = psc;
+ gc->mode = fbconfig;
+ gc->isDirect = GL_TRUE;
}
+ }
#endif
- LockDisplay(dpy);
- switch (code) {
- case X_GLXCreateContext: {
- xGLXCreateContextReq *req;
-
- /* Send the glXCreateContext request */
- GetReq(GLXCreateContext, req);
- req->reqType = gc->majorOpcode;
- req->glxCode = X_GLXCreateContext;
- req->context = gc->xid = XAllocID(dpy);
- req->visual = vis->visualid;
- req->screen = vis->screen;
- req->shareList = shareList ? shareList->xid : None;
- req->isDirect = GC_IS_DIRECT(gc);
- break;
- }
+ LockDisplay(dpy);
+ switch (code) {
+ case X_GLXCreateContext: {
+ xGLXCreateContextReq *req;
+
+ /* Send the glXCreateContext request */
+ GetReq(GLXCreateContext, req);
+ req->reqType = gc->majorOpcode;
+ req->glxCode = X_GLXCreateContext;
+ req->context = gc->xid = XAllocID(dpy);
+ req->visual = generic_id;
+ req->screen = screen;
+ req->shareList = shareList ? shareList->xid : None;
+ req->isDirect = GC_IS_DIRECT(gc);
+ break;
+ }
- case X_GLXCreateNewContext: {
- xGLXCreateNewContextReq *req;
-
- /* Send the glXCreateNewContext request */
- GetReq(GLXCreateNewContext, req);
- req->reqType = gc->majorOpcode;
- req->glxCode = X_GLXCreateNewContext;
- req->context = gc->xid = XAllocID(dpy);
- req->fbconfig = fbconfig->fbconfigID;
- req->screen = fbconfig->screen;
- req->renderType = renderType;
- req->shareList = shareList ? shareList->xid : None;
- req->isDirect = GC_IS_DIRECT(gc);
- break;
- }
+ case X_GLXCreateNewContext: {
+ xGLXCreateNewContextReq *req;
- case X_GLXvop_CreateContextWithConfigSGIX: {
- xGLXVendorPrivateWithReplyReq *vpreq;
- xGLXCreateContextWithConfigSGIXReq *req;
-
- /* Send the glXCreateNewContext request */
- GetReqExtra(GLXVendorPrivateWithReply,
- sz_xGLXCreateContextWithConfigSGIXReq -
- sz_xGLXVendorPrivateWithReplyReq, vpreq);
- req = (xGLXCreateContextWithConfigSGIXReq *) vpreq;
- req->reqType = gc->majorOpcode;
- req->glxCode = X_GLXVendorPrivateWithReply;
- req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
- req->context = gc->xid = XAllocID(dpy);
- req->fbconfig = fbconfig->fbconfigID;
- req->screen = fbconfig->screen;
- req->renderType = renderType;
- req->shareList = shareList ? shareList->xid : None;
- req->isDirect = GC_IS_DIRECT(gc);
- break;
- }
+ /* Send the glXCreateNewContext request */
+ GetReq(GLXCreateNewContext, req);
+ req->reqType = gc->majorOpcode;
+ req->glxCode = X_GLXCreateNewContext;
+ req->context = gc->xid = XAllocID(dpy);
+ req->fbconfig = generic_id;
+ req->screen = screen;
+ req->renderType = renderType;
+ req->shareList = shareList ? shareList->xid : None;
+ req->isDirect = GC_IS_DIRECT(gc);
+ break;
+ }
- default:
- /* What to do here? This case is the sign of an internal error. It
- * should never be reachable.
- */
- break;
- }
+ case X_GLXvop_CreateContextWithConfigSGIX: {
+ xGLXVendorPrivateWithReplyReq *vpreq;
+ xGLXCreateContextWithConfigSGIXReq *req;
- UnlockDisplay(dpy);
- SyncHandle();
- gc->imported = GL_FALSE;
+ /* Send the glXCreateNewContext request */
+ GetReqExtra(GLXVendorPrivateWithReply,
+ sz_xGLXCreateContextWithConfigSGIXReq -
+ sz_xGLXVendorPrivateWithReplyReq, vpreq);
+ req = (xGLXCreateContextWithConfigSGIXReq *) vpreq;
+ req->reqType = gc->majorOpcode;
+ req->glxCode = X_GLXVendorPrivateWithReply;
+ req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
+ req->context = gc->xid = XAllocID(dpy);
+ req->fbconfig = generic_id;
+ req->screen = screen;
+ req->renderType = renderType;
+ req->shareList = shareList ? shareList->xid : None;
+ req->isDirect = GC_IS_DIRECT(gc);
+ break;
}
- else {
- gc->xid = contextID;
- gc->imported = GL_TRUE;
+
+ default:
+ /* What to do here? This case is the sign of an internal error. It
+ * should never be reachable.
+ */
+ break;
}
+ UnlockDisplay(dpy);
+ SyncHandle();
+
+ gc->imported = GL_FALSE;
gc->renderType = renderType;
return gc;
glXCreateContext(Display * dpy, XVisualInfo * vis,
GLXContext shareList, Bool allowDirect)
{
- return CreateContext(dpy, vis, NULL, shareList, allowDirect, None,
- X_GLXCreateContext, 0, vis->screen);
+ const __GLcontextModes *mode = NULL;
+ int renderType = 0;
+
+#ifdef GLX_DIRECT_RENDERING
+ __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, vis->screen);
+
+ mode = _gl_context_modes_find_visual(psc->visuals, vis->visualid);
+ if (mode == NULL) {
+ xError error;
+
+ error.errorCode = BadValue;
+ error.resourceID = vis->visualid;
+ error.sequenceNumber = dpy->request;
+ error.type = X_Error;
+ error.majorCode = __glXSetupForCommand(dpy);
+ error.minorCode = X_GLXCreateContext;
+ _XError(dpy, &error);
+ return None;
+ }
+
+ renderType = mode->rgbMode ? GLX_RGBA_TYPE : GLX_COLOR_INDEX_TYPE;
+#endif
+
+ return CreateContext(dpy, vis->visualid, mode, shareList, allowDirect,
+ X_GLXCreateContext, renderType, vis->screen);
}
_X_HIDDEN void
return NULL;
}
- /* FIXME: Why does this call CreateContext? There is no protocol sent for
- * FIXME: this function.
- */
- ctx = CreateContext(dpy, NULL, NULL, NULL, False, contextID,
- X_GLXCreateContext, 0, 0);
+ ctx = AllocateGLXContext(dpy);
if (NULL != ctx) {
+ ctx->xid = contextID;
+ ctx->imported = GL_TRUE;
+
if (Success != __glXQueryContextInfo(dpy, ctx)) {
- return NULL;
+ __glXFreeContext(ctx);
+ ctx = NULL;
}
}
return ctx;
const __GLcontextModes *const fbconfig =
(const __GLcontextModes *const) config;
- return CreateContext(dpy, NULL, fbconfig, shareList,
- allowDirect, None, X_GLXCreateNewContext, renderType,
+ return CreateContext(dpy, fbconfig->fbconfigID, fbconfig, shareList,
+ allowDirect, X_GLXCreateNewContext, renderType,
fbconfig->screen);
}
#endif
psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
+#ifdef GLX_DIRECT_RENDERING
if (gc->driContext && psc->driScreen && psc->driScreen->setSwapInterval) {
__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(gc->currentDpy,
gc->currentDrawable,
psc->driScreen->setSwapInterval(pdraw, interval);
return 0;
}
+#endif
dpy = gc->currentDpy;
opcode = __glXSetupForCommand(dpy);
}
#endif
+#ifdef GLX_DIRECT_RENDERING
if (gc != NULL && gc->driContext) {
__GLXscreenConfigs *psc;
return 0;
}
}
+#endif
return GLX_BAD_CONTEXT;
}
}
}
#endif
+
+#ifdef GLX_DIRECT_RENDERING
if (gc != NULL && gc->driContext) {
__GLXscreenConfigs *psc;
return psc->driScreen->getSwapInterval(pdraw);
}
}
+#endif
return 0;
}
int ret;
GLXContext gc = __glXGetCurrentContext();
__GLXscreenConfigs *psc;
+#ifdef GLX_DIRECT_RENDERING
__GLXDRIdrawable *pdraw;
+#endif
- if (!gc || !gc->driContext)
+ if (!gc)
return GLX_BAD_CONTEXT;
+#ifdef GLX_DIRECT_RENDERING
+ if (!gc->driContext)
+ return GLX_BAD_CONTEXT;
+#endif
+
psc = GetGLXScreenConfigs(gc->currentDpy, gc->screen);
+#ifdef GLX_DIRECT_RENDERING
pdraw = GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+#endif
/* FIXME: Looking at the GLX_SGI_video_sync spec in the extension registry,
* FIXME: there should be a GLX encoding for this call. I can find no
return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
}
#endif
+
+#ifdef GLX_DIRECT_RENDERING
if (psc->driScreen && psc->driScreen->getDrawableMSC) {
ret = psc->driScreen->getDrawableMSC(psc, pdraw, &ust, &msc, &sbc);
*count = (unsigned) msc;
return (ret == True) ? 0 : GLX_BAD_CONTEXT;
}
+#endif
return GLX_BAD_CONTEXT;
}
{
GLXContext gc = __glXGetCurrentContext();
__GLXscreenConfigs *psc;
+#ifdef GLX_DIRECT_RENDERING
__GLXDRIdrawable *pdraw;
+#endif
int64_t ust, msc, sbc;
int ret;
if (divisor <= 0 || remainder < 0)
return GLX_BAD_VALUE;
- if (!gc || !gc->driContext)
+ if (!gc)
return GLX_BAD_CONTEXT;
+#ifdef GLX_DIRECT_RENDERING
+ if (!gc->driContext)
+ return GLX_BAD_CONTEXT;
+#endif
+
psc = GetGLXScreenConfigs( gc->currentDpy, gc->screen);
+#ifdef GLX_DIRECT_RENDERING
pdraw = GetGLXDRIDrawable(gc->currentDpy, gc->currentDrawable, NULL);
+#endif
#ifdef __DRI_MEDIA_STREAM_COUNTER
if (psc->msc != NULL && psc->driScreen ) {
return (ret == 0) ? 0 : GLX_BAD_CONTEXT;
}
#endif
+
+#ifdef GLX_DIRECT_RENDERING
if (psc->driScreen && psc->driScreen->waitForMSC) {
ret = psc->driScreen->waitForMSC(pdraw, 0, divisor, remainder, &ust, &msc,
&sbc);
*count = (unsigned) msc;
return (ret == True) ? 0 : GLX_BAD_CONTEXT;
}
+#endif
return GLX_BAD_CONTEXT;
}
psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
if ((psc != NULL)
&& __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)) {
- gc = CreateContext(dpy, NULL, (__GLcontextModes *) config, shareList,
- allowDirect, None,
+ gc = CreateContext(dpy, fbconfig->fbconfigID, fbconfig, shareList,
+ allowDirect,
X_GLXvop_CreateContextWithConfigSGIX, renderType,
fbconfig->screen);
}
{
__GLXdisplayPrivate * const priv = __glXInitialize(dpy);
int i, ret;
+#ifdef GLX_DIRECT_RENDERING
__GLXDRIdrawable *pdraw;
+#endif
__GLXscreenConfigs *psc;
if (!priv)
return False;
+#ifdef GLX_DIRECT_RENDERING
pdraw = GetGLXDRIDrawable(dpy, drawable, &i);
+#endif
psc = &priv->screenConfigs[i];
#if defined(__DRI_SWAP_BUFFER_COUNTER) && defined(__DRI_MEDIA_STREAM_COUNTER)
- if (pdraw && psc->sbc && psc->sbc)
+ if (pdraw && psc->sbc && psc->msc)
return ( (pdraw && psc->sbc && psc->msc)
&& ((*psc->msc->getMSC)(psc->driScreen, msc) == 0)
&& ((*psc->sbc->getSBC)(pdraw->driDrawable, sbc) == 0)
&& (__glXGetUST(ust) == 0) );
#endif
+
+#ifdef GLX_DIRECT_RENDERING
if (pdraw && psc && psc->driScreen && psc->driScreen->getDrawableMSC) {
ret = psc->driScreen->getDrawableMSC(psc, pdraw, ust, msc, sbc);
return ret;
}
+#endif
return False;
}
{
GLXContext gc = __glXGetCurrentContext();
int screen;
+#ifdef GLX_DIRECT_RENDERING
__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+#endif
__GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
- if (!pdraw || !gc->driContext) /* no GLX for this */
+ if (!gc) /* no GLX for this */
+ return -1;
+
+#ifdef GLX_DIRECT_RENDERING
+ if (!pdraw || !gc->driContext)
return -1;
+#endif
/* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
* error", but it also says "It [glXSwapBuffersMscOML] will return a value
if (divisor > 0 && remainder >= divisor)
return -1;
+ if (target_msc == 0 && divisor == 0 && remainder == 0)
+ remainder = 1;
+
#ifdef __DRI_SWAP_BUFFER_COUNTER
if (psc->counters != NULL)
return (*psc->sbc->swapBuffersMSC)(pdraw->driDrawable, target_msc,
int64_t * msc, int64_t * sbc)
{
int screen;
+#ifdef GLX_DIRECT_RENDERING
__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+#endif
__GLXscreenConfigs * const psc = GetGLXScreenConfigs( dpy, screen );
int ret;
- fprintf(stderr, "waitmsc: %lld, %lld, %lld\n", target_msc, divisor,
- remainder);
/* The OML_sync_control spec says these should "generate a GLX_BAD_VALUE
* error", but the return type in the spec is Bool.
#ifdef __DRI_MEDIA_STREAM_COUNTER
if (pdraw != NULL && psc->msc != NULL) {
- fprintf(stderr, "dri1 msc\n");
ret = (*psc->msc->waitForMSC) (pdraw->driDrawable, target_msc,
divisor, remainder, msc, sbc);
return ((ret == 0) && (__glXGetUST(ust) == 0));
}
#endif
+
+#ifdef GLX_DIRECT_RENDERING
if (pdraw && psc->driScreen && psc->driScreen->waitForMSC) {
ret = psc->driScreen->waitForMSC(pdraw, target_msc, divisor, remainder,
ust, msc, sbc);
return ret;
}
+#endif
- fprintf(stderr, "no drawable??\n");
return False;
}
int64_t * msc, int64_t * sbc)
{
int screen;
+#ifdef GLX_DIRECT_RENDERING
__GLXDRIdrawable *pdraw = GetGLXDRIDrawable(dpy, drawable, &screen);
+#endif
__GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
int ret;
return ((ret == 0) && (__glXGetUST(ust) == 0));
}
#endif
- if (pdraw && psc->driScreen && psc->driScreen->waitForMSC) {
+
+#ifdef GLX_DIRECT_RENDERING
+ if (pdraw && psc->driScreen && psc->driScreen->waitForSBC) {
ret = psc->driScreen->waitForSBC(pdraw, target_sbc, ust, msc, sbc);
return ret;
}
+#endif
+
return False;
}