Merge branch '7.8'

[mesa.git] / src / glx / glxcmds.c

diff --git a/src/glx/glxcmds.c b/src/glx/glxcmds.c
index 1be6ff397946d51166e620cb1c89f5cf93500313..7cdd42caf028aa989dad0e1cc4011e7a876fdbc7 100644 (file)
--- a/src/glx/glxcmds.c
+++ b/src/glx/glxcmds.c
@@ -110,10 +110,6 @@ GarbageCollectDRIDrawables(Display * dpy, __GLXscreenConfigs * sc)
    XSetErrorHandler(oldXErrorHandler);
 }
 
-extern __GLXDRIdrawable *GetGLXDRIDrawable(Display * dpy,
-                                           GLXDrawable drawable,
-                                           int *const scrn_num);
-
 /**
  * Get the __DRIdrawable for the drawable associated with a GLXContext
  *
@@ -362,7 +358,7 @@ AllocateGLXContext(Display * dpy)
  */
 
 static GLXContext
-CreateContext(Display * dpy, XVisualInfo * vis,
+CreateContext(Display * dpy, int generic_id,
               const __GLcontextModes * const fbconfig,
               GLXContext shareList,
               Bool allowDirect,
@@ -371,18 +367,16 @@ CreateContext(Display * dpy, XVisualInfo * vis,
    GLXContext gc;
 #ifdef GLX_DIRECT_RENDERING
    __GLXscreenConfigs *const psc = GetGLXScreenConfigs(dpy, screen);
-#else
-   (void) screen;
 #endif
 
    if (dpy == NULL)
       return NULL;
 
-   gc = AllocateGLXContext(dpy);
-   if (!gc)
+   if (generic_id == None)
       return NULL;
 
-   if ((vis == NULL) && (fbconfig == NULL))
+   gc = AllocateGLXContext(dpy);
+   if (!gc)
       return NULL;
 
 #ifdef GLX_DIRECT_RENDERING
@@ -408,8 +402,8 @@ CreateContext(Display * dpy, XVisualInfo * vis,
       req->reqType = gc->majorOpcode;
       req->glxCode = X_GLXCreateContext;
       req->context = gc->xid = XAllocID(dpy);
-      req->visual = vis->visualid;
-      req->screen = vis->screen;
+      req->visual = generic_id;
+      req->screen = screen;
       req->shareList = shareList ? shareList->xid : None;
       req->isDirect = GC_IS_DIRECT(gc);
       break;
@@ -423,8 +417,8 @@ CreateContext(Display * dpy, XVisualInfo * vis,
       req->reqType = gc->majorOpcode;
       req->glxCode = X_GLXCreateNewContext;
       req->context = gc->xid = XAllocID(dpy);
-      req->fbconfig = fbconfig->fbconfigID;
-      req->screen = fbconfig->screen;
+      req->fbconfig = generic_id;
+      req->screen = screen;
       req->renderType = renderType;
       req->shareList = shareList ? shareList->xid : None;
       req->isDirect = GC_IS_DIRECT(gc);
@@ -444,8 +438,8 @@ CreateContext(Display * dpy, XVisualInfo * vis,
       req->glxCode = X_GLXVendorPrivateWithReply;
       req->vendorCode = X_GLXvop_CreateContextWithConfigSGIX;
       req->context = gc->xid = XAllocID(dpy);
-      req->fbconfig = fbconfig->fbconfigID;
-      req->screen = fbconfig->screen;
+      req->fbconfig = generic_id;
+      req->screen = screen;
       req->renderType = renderType;
       req->shareList = shareList ? shareList->xid : None;
       req->isDirect = GC_IS_DIRECT(gc);
@@ -495,7 +489,7 @@ glXCreateContext(Display * dpy, XVisualInfo * vis,
    renderType = mode->rgbMode ? GLX_RGBA_TYPE : GLX_COLOR_INDEX_TYPE;
 #endif
 
-   return CreateContext(dpy, vis, mode, shareList, allowDirect,
+   return CreateContext(dpy, vis->visualid, mode, shareList, allowDirect,
                         X_GLXCreateContext, renderType, vis->screen);
 }
 
@@ -1801,7 +1795,7 @@ glXCreateNewContext(Display * dpy, GLXFBConfig config,
    const __GLcontextModes *const fbconfig =
       (const __GLcontextModes *const) config;
 
-   return CreateContext(dpy, NULL, fbconfig, shareList,
+   return CreateContext(dpy, fbconfig->fbconfigID, fbconfig, shareList,
                         allowDirect, X_GLXCreateNewContext, renderType,
                        fbconfig->screen);
 }
@@ -1923,6 +1917,7 @@ __glXSwapIntervalSGI(int interval)
 #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,
@@ -1930,6 +1925,7 @@ __glXSwapIntervalSGI(int interval)
       psc->driScreen->setSwapInterval(pdraw, interval);
       return 0;
    }
+#endif
 
    dpy = gc->currentDpy;
    opcode = __glXSetupForCommand(dpy);
@@ -1980,6 +1976,7 @@ __glXSwapIntervalMESA(unsigned int interval)
    }
 #endif
 
+#ifdef GLX_DIRECT_RENDERING
    if (gc != NULL && gc->driContext) {
       __GLXscreenConfigs *psc;
 
@@ -1991,6 +1988,7 @@ __glXSwapIntervalMESA(unsigned int interval)
         return 0;
       }
    }
+#endif
 
    return GLX_BAD_CONTEXT;
 }
@@ -2015,6 +2013,8 @@ __glXGetSwapIntervalMESA(void)
       }
    }
 #endif
+
+#ifdef GLX_DIRECT_RENDERING
    if (gc != NULL && gc->driContext) {
       __GLXscreenConfigs *psc;
 
@@ -2025,6 +2025,7 @@ __glXGetSwapIntervalMESA(void)
         return psc->driScreen->getSwapInterval(pdraw);
       }
    }
+#endif
 
    return 0;
 }
@@ -2141,13 +2142,22 @@ __glXGetVideoSyncSGI(unsigned int *count)
    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
@@ -2162,11 +2172,14 @@ __glXGetVideoSyncSGI(unsigned int *count)
       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;
 }
@@ -2176,18 +2189,27 @@ __glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
 {
    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 ) {
@@ -2197,12 +2219,15 @@ __glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
       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;
 }
@@ -2290,7 +2315,7 @@ glXCreateContextWithConfigSGIX(Display * dpy,
    psc = GetGLXScreenConfigs(dpy, fbconfig->screen);
    if ((psc != NULL)
        && __glXExtensionBitIsEnabled(psc, SGIX_fbconfig_bit)) {
-      gc = CreateContext(dpy, NULL, (__GLcontextModes *) config, shareList,
+      gc = CreateContext(dpy, fbconfig->fbconfigID, fbconfig, shareList,
                          allowDirect,
                         X_GLXvop_CreateContextWithConfigSGIX, renderType,
                         fbconfig->screen);
@@ -2360,26 +2385,33 @@ __glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable,
 {
    __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;
 }
@@ -2497,12 +2529,19 @@ __glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable,
 {
    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
     * of -1 if the function failed because of errors detected in the input
@@ -2513,6 +2552,9 @@ __glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable,
    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,
@@ -2536,12 +2578,12 @@ __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
                    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.
@@ -2553,7 +2595,6 @@ __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
 
 #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);
 
@@ -2563,13 +2604,15 @@ __glXWaitForMscOML(Display * dpy, GLXDrawable drawable,
       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;
 }
 
@@ -2580,7 +2623,9 @@ __glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
                    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;
 
@@ -2600,10 +2645,14 @@ __glXWaitForSbcOML(Display * dpy, GLXDrawable drawable,
       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;
 }