xserver: Branch 'master' - 9 commits
Kristian Høgsberg
krh at kemper.freedesktop.org
Fri Oct 12 16:29:20 PDT 2007
GL/glx/glxcmds.c | 607 ++++++++++++++++++++++-----------------------
GL/glx/glxcmdsswap.c | 25 +
GL/glx/glxcontext.h | 18 -
GL/glx/glxdrawable.h | 35 +-
GL/glx/glxdri.c | 540 ++++++++++++++++------------------------
GL/glx/glxext.c | 253 +++++++-----------
GL/glx/glxext.h | 25 -
GL/glx/glxglcore.c | 5
GL/glx/glxscreens.c | 152 +++--------
GL/glx/glxscreens.h | 29 +-
GL/glx/glxserver.h | 5
GL/glx/glxutil.c | 11
GL/glx/glxutil.h | 2
GL/glx/indirect_dispatch.h | 22 +
GL/glx/indirect_size_get.c | 4
GL/glx/indirect_table.c | 6
configure.ac | 2
hw/xfree86/dri/dri.c | 4
18 files changed, 776 insertions(+), 969 deletions(-)
New commits:
diff-tree 927757e1028f45f7fd94b9a2ab35567e0f34b2a8 (from parents)
Merge: ccda4b66bdfc179e661b24adc8ec72bb7db75b2b 17ffc34ad5e9a8e2269afef05f209701f1895c01
Author: Kristian Høgsberg <krh at redhat.com>
Date: Fri Oct 12 19:28:39 2007 -0400
Merge branch 'master' of git://git.freedesktop.org/git/xorg/xserver
diff-tree ccda4b66bdfc179e661b24adc8ec72bb7db75b2b (from 695eb8b2e88abc9fa3a76d8da48c3214c7dd1f08)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Mon Aug 27 14:43:48 2007 -0400
Implement ChangeDrawableAttributes so we can support GLX_EVENT_MASK.
We never need to actually send out the clobber event, so this should be
sufficient for GLX 1.3.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index f838f21..91c80b2 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -1385,14 +1385,35 @@ int __glXDisp_DestroyGLXPbufferSGIX(__GL
return DoDestroyDrawable(cl, req->pbuffer, GLX_DRAWABLE_PBUFFER);
}
+static int
+DoChangeDrawableAttributes(ClientPtr client, XID glxdrawable,
+ int numAttribs, CARD32 *attribs)
+{
+ __GLXdrawable *pGlxDraw;
+ int i;
+
+ pGlxDraw = LookupIDByType(glxdrawable, __glXDrawableRes);
+ for (i = 0; i < numAttribs; i++) {
+ switch(attribs[i * 2]) {
+ case GLX_EVENT_MASK:
+ /* All we do is to record the event mask so we can send it
+ * back when queried. We never actually clobber the
+ * pbuffers, so we never need to send out the event. */
+ pGlxDraw->eventMask = attribs[i * 2 + 1];
+ break;
+ }
+ }
+
+ return Success;
+}
+
int __glXDisp_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXChangeDrawableAttributesReq *req =
(xGLXChangeDrawableAttributesReq *) pc;
- (void) req;
-
- return BadRequest;
+ return DoChangeDrawableAttributes(cl->client, req->drawable,
+ req->numAttribs, (CARD32 *) (req + 1));
}
int __glXDisp_ChangeDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
@@ -1400,9 +1421,8 @@ int __glXDisp_ChangeDrawableAttributesSG
xGLXChangeDrawableAttributesSGIXReq *req =
(xGLXChangeDrawableAttributesSGIXReq *)pc;
- (void) req;
-
- return BadRequest;
+ return DoChangeDrawableAttributes(cl->client, req->drawable,
+ req->numAttribs, (CARD32 *) (req + 1));
}
int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
@@ -1676,7 +1696,7 @@ DoGetDrawableAttributes(__GLXclientState
ClientPtr client = cl->client;
xGLXGetDrawableAttributesReply reply;
__GLXdrawable *pGlxDraw;
- CARD32 attributes[4];
+ CARD32 attributes[6];
int numAttribs, error;
pGlxDraw = __glXGetDrawable(NULL, drawId, client, &error);
@@ -1685,7 +1705,7 @@ DoGetDrawableAttributes(__GLXclientState
return error;
}
- numAttribs = 2;
+ numAttribs = 3;
reply.length = numAttribs << 1;
reply.type = X_Reply;
reply.sequenceNumber = client->sequence;
@@ -1696,6 +1716,8 @@ DoGetDrawableAttributes(__GLXclientState
GLX_TEXTURE_RECTANGLE_EXT;
attributes[2] = GLX_Y_INVERTED_EXT;
attributes[3] = GL_FALSE;
+ attributes[4] = GLX_EVENT_MASK;
+ attributes[5] = pGlxDraw->eventMask;
if (client->swapped) {
__glXSwapGetDrawableAttributesReply(client, &reply, attributes);
diff --git a/GL/glx/glxdrawable.h b/GL/glx/glxdrawable.h
index 247e7a2..858bbb3 100644
--- a/GL/glx/glxdrawable.h
+++ b/GL/glx/glxdrawable.h
@@ -95,6 +95,11 @@ struct __GLXdrawable {
int refCount;
GLenum target;
+
+ /*
+ ** Event mask
+ */
+ unsigned long eventMask;
};
#endif /* !__GLX_drawable_h__ */
diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c
index 9479a58..f531ed9 100644
--- a/GL/glx/glxutil.c
+++ b/GL/glx/glxutil.c
@@ -147,6 +147,7 @@ __glXDrawableInit(__GLXdrawable *drawabl
drawable->drawId = drawId;
drawable->refCount = 1;
drawable->modes = modes;
+ drawable->eventMask = 0;
return GL_TRUE;
}
diff-tree 695eb8b2e88abc9fa3a76d8da48c3214c7dd1f08 (from 516c181f57367847c3f317f8f8f5cc3211026f4c)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Mon Aug 27 14:23:50 2007 -0400
Implement GLX pbuffers.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index 0d576c1..f838f21 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -488,7 +488,8 @@ __glXGetDrawable(__GLXcontext *glxc, GLX
}
pGlxDraw = glxc->pGlxScreen->createDrawable(glxc->pGlxScreen,
- pDraw, drawId, modes);
+ pDraw, GLX_DRAWABLE_WINDOW,
+ drawId, modes);
/* since we are creating the drawablePrivate, drawId should be new */
if (!AddResource(drawId, __glXDrawableRes, pGlxDraw)) {
@@ -1127,24 +1128,17 @@ int __glXDisp_GetFBConfigsSGIX(__GLXclie
static int
DoCreateGLXDrawable(ClientPtr client, int screenNum, XID fbconfigId,
- XID drawableId, XID glxDrawableId, int type)
+ DrawablePtr pDraw, XID glxDrawableId, int type)
{
- DrawablePtr pDraw;
ScreenPtr pScreen;
VisualPtr pVisual;
__GLXscreen *pGlxScreen;
__GLXdrawable *pGlxDraw;
__GLcontextModes *modes;
- int i, rc;
+ int i;
LEGAL_NEW_RESOURCE(glxDrawableId, client);
- rc = dixLookupDrawable(&pDraw, drawableId, client, 0, DixUnknownAccess);
- if (rc != Success || pDraw->type != type) {
- client->errorValue = drawableId;
- return type == DRAWABLE_WINDOW ? BadWindow : BadPixmap;
- }
-
/* Check if screen of the fbconfig matches screen of drawable. */
pScreen = pDraw->pScreen;
if (screenNum != pScreen->myNum)
@@ -1169,7 +1163,7 @@ DoCreateGLXDrawable(ClientPtr client, in
/* FIXME: We need to check that the window visual is compatible
* with the specified fbconfig. */
- pGlxDraw = pGlxScreen->createDrawable(pGlxScreen, pDraw,
+ pGlxDraw = pGlxScreen->createDrawable(pGlxScreen, pDraw, type,
glxDrawableId, modes);
if (pGlxDraw == NULL)
return BadAlloc;
@@ -1179,10 +1173,29 @@ DoCreateGLXDrawable(ClientPtr client, in
return BadAlloc;
}
- if (type == DRAWABLE_PIXMAP)
+ return Success;
+}
+
+static int
+DoCreateGLXPixmap(ClientPtr client, int screenNum, XID fbconfigId,
+ XID drawableId, XID glxDrawableId)
+{
+ DrawablePtr pDraw;
+ int err;
+
+ err = dixLookupDrawable(&pDraw, drawableId, client, 0, DixUnknownAccess);
+ if (err != Success || pDraw->type != DRAWABLE_PIXMAP) {
+ client->errorValue = drawableId;
+ return BadPixmap;
+ }
+
+ err = DoCreateGLXDrawable(client, screenNum, fbconfigId, pDraw,
+ glxDrawableId, GLX_DRAWABLE_PIXMAP);
+
+ if (err == Success)
((PixmapPtr) pDraw)->refcnt++;
- return Success;
+ return err;
}
static void
@@ -1223,8 +1236,8 @@ int __glXDisp_CreateGLXPixmap(__GLXclien
{
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
- return DoCreateGLXDrawable(cl->client, req->screen, req->visual,
- req->pixmap, req->glxpixmap, DRAWABLE_PIXMAP);
+ return DoCreateGLXPixmap(cl->client, req->screen, req->visual,
+ req->pixmap, req->glxpixmap);
}
int __glXDisp_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
@@ -1232,8 +1245,8 @@ int __glXDisp_CreatePixmap(__GLXclientSt
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
int err;
- err = DoCreateGLXDrawable(cl->client, req->screen, req->fbconfig,
- req->pixmap, req->glxpixmap, DRAWABLE_PIXMAP);
+ err = DoCreateGLXPixmap(cl->client, req->screen, req->fbconfig,
+ req->pixmap, req->glxpixmap);
if (err != Success)
return err;
@@ -1248,8 +1261,8 @@ int __glXDisp_CreateGLXPixmapWithConfigS
xGLXCreateGLXPixmapWithConfigSGIXReq *req =
(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
- return DoCreateGLXDrawable(cl->client, req->screen, req->fbconfig,
- req->pixmap, req->glxpixmap, DRAWABLE_PIXMAP);
+ return DoCreateGLXPixmap(cl->client, req->screen, req->fbconfig,
+ req->pixmap, req->glxpixmap);
}
@@ -1257,7 +1270,6 @@ static int DoDestroyDrawable(__GLXclient
{
ClientPtr client = cl->client;
__GLXdrawable *pGlxDraw;
- int error;
/*
** Check it's the right type of drawable.
@@ -1265,8 +1277,14 @@ static int DoDestroyDrawable(__GLXclient
pGlxDraw = LookupIDByType(glxdrawable, __glXDrawableRes);
if (pGlxDraw == NULL || pGlxDraw->type != type) {
client->errorValue = glxdrawable;
- error = type == DRAWABLE_WINDOW ? GLXBadWindow : GLXBadDrawable;
- return __glXError(error);
+ switch (type) {
+ case GLX_DRAWABLE_WINDOW:
+ return __glXError(GLXBadWindow);
+ case GLX_DRAWABLE_PIXMAP:
+ return __glXError(GLXBadDrawable);
+ case GLX_DRAWABLE_PBUFFER:
+ return __glXError(GLXBadPbuffer);
+ }
}
FreeResource(glxdrawable, FALSE);
@@ -1277,50 +1295,94 @@ int __glXDisp_DestroyGLXPixmap(__GLXclie
{
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
- return DoDestroyDrawable(cl, req->glxpixmap, DRAWABLE_PIXMAP);
+ return DoDestroyDrawable(cl, req->glxpixmap, GLX_DRAWABLE_PIXMAP);
}
int __glXDisp_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPixmapReq *req = (xGLXDestroyPixmapReq *) pc;
- return DoDestroyDrawable(cl, req->glxpixmap, DRAWABLE_PIXMAP);
+ return DoDestroyDrawable(cl, req->glxpixmap, GLX_DRAWABLE_PIXMAP);
}
-int __glXDisp_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
+static int
+DoCreatePbuffer(ClientPtr client, int screenNum, XID fbconfigId,
+ int width, int height, XID glxDrawableId)
{
- xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
+ ScreenPtr pScreen;
+ VisualPtr pVisual;
+ PixmapPtr pPixmap;
+ int i;
- (void) req;
+ pScreen = screenInfo.screens[screenNum];
- return BadRequest;
+ pVisual = pScreen->visuals;
+ for (i = 0; i < pScreen->numVisuals; i++, pVisual++) {
+ if (pVisual->vid == fbconfigId)
+ break;
+ }
+ if (i == pScreen->numVisuals)
+ return __glXError(GLXBadFBConfig);
+
+ __glXenterServer(GL_FALSE);
+ pPixmap = (*pScreen->CreatePixmap) (pScreen,
+ width, height, pVisual->nplanes);
+ __glXleaveServer(GL_FALSE);
+
+ return DoCreateGLXDrawable(client, screenNum, fbconfigId,
+ &pPixmap->drawable, glxDrawableId,
+ GLX_DRAWABLE_PBUFFER);
+}
+
+int __glXDisp_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
+{
+ xGLXCreatePbufferReq *req = (xGLXCreatePbufferReq *) pc;
+ CARD32 *attrs;
+ int width, height, i;
+
+ attrs = (CARD32 *) (req + 1);
+ width = 0;
+ height = 0;
+
+ for (i = 0; i < req->numAttribs; i++) {
+ switch (attrs[i * 2]) {
+ case GLX_PBUFFER_WIDTH:
+ width = attrs[i * 2 + 1];
+ break;
+ case GLX_PBUFFER_HEIGHT:
+ height = attrs[i * 2 + 1];
+ break;
+ case GLX_LARGEST_PBUFFER:
+ case GLX_PRESERVED_CONTENTS:
+ /* FIXME: huh... */
+ break;
+ }
+ }
+
+ return DoCreatePbuffer(cl->client, req->screen, req->fbconfig,
+ width, height, req->pbuffer);
}
int __glXDisp_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
- (void) req;
-
- return BadRequest;
+ return DoCreatePbuffer(cl->client, req->screen, req->fbconfig,
+ req->width, req->height, req->pbuffer);
}
int __glXDisp_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
- (void) req;
-
- return BadRequest;
+ return DoDestroyDrawable(cl, req->pbuffer, GLX_DRAWABLE_PBUFFER);
}
-__glXDisp_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+int __glXDisp_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc;
- (void) req;
-
- return BadRequest;
+ return DoDestroyDrawable(cl, req->pbuffer, GLX_DRAWABLE_PBUFFER);
}
int __glXDisp_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
@@ -1345,18 +1407,26 @@ int __glXDisp_ChangeDrawableAttributesSG
int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
{
- xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
- ClientPtr client = cl->client;
+ xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
+ ClientPtr client = cl->client;
+ DrawablePtr pDraw;
+ int err;
+
+ err = dixLookupDrawable(&pDraw, req->window, client, 0, DixUnknownAccess);
+ if (err != Success || pDraw->type != DRAWABLE_WINDOW) {
+ client->errorValue = req->window;
+ return BadWindow;
+ }
return DoCreateGLXDrawable(client, req->screen, req->fbconfig,
- req->window, req->glxwindow, DRAWABLE_WINDOW);
+ pDraw, req->glxwindow, GLX_DRAWABLE_WINDOW);
}
int __glXDisp_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
- return DoDestroyDrawable(cl, req->glxwindow, DRAWABLE_WINDOW);
+ return DoDestroyDrawable(cl, req->glxwindow, GLX_DRAWABLE_WINDOW);
}
@@ -1493,7 +1563,7 @@ int __glXDisp_BindTexImageEXT(__GLXclien
return error;
pGlxDraw = __glXGetDrawable(NULL, drawId, client, &error);
- if (!pGlxDraw || pGlxDraw->type != DRAWABLE_PIXMAP) {
+ if (!pGlxDraw || pGlxDraw->type != GLX_DRAWABLE_PIXMAP) {
client->errorValue = drawId;
return __glXError(GLXBadPixmap);
}
@@ -1526,7 +1596,7 @@ int __glXDisp_ReleaseTexImageEXT(__GLXcl
return error;
pGlxDraw = __glXGetDrawable(NULL, drawId, client, &error);
- if (error != Success || pGlxDraw->type != DRAWABLE_PIXMAP) {
+ if (error != Success || pGlxDraw->type != GLX_DRAWABLE_PIXMAP) {
client->errorValue = drawId;
return error;
}
@@ -1588,7 +1658,7 @@ int __glXDisp_CopySubBufferMESA(__GLXcli
return error;
if (pGlxDraw == NULL ||
- pGlxDraw->type != DRAWABLE_WINDOW ||
+ pGlxDraw->type != GLX_DRAWABLE_WINDOW ||
pGlxDraw->copySubBuffer == NULL)
return __glXError(GLXBadDrawable);
diff --git a/GL/glx/glxdrawable.h b/GL/glx/glxdrawable.h
index 5fdcf95..247e7a2 100644
--- a/GL/glx/glxdrawable.h
+++ b/GL/glx/glxdrawable.h
@@ -46,6 +46,13 @@
#include <GL/internal/dri_interface.h>
#endif
+/* We just need to avoid clashing with DRAWABLE_{WINDOW,PIXMAP} */
+enum {
+ GLX_DRAWABLE_WINDOW,
+ GLX_DRAWABLE_PIXMAP,
+ GLX_DRAWABLE_PBUFFER
+};
+
struct __GLXdrawable {
void (*destroy)(__GLXdrawable *private);
GLboolean (*resize)(__GLXdrawable *private);
@@ -63,9 +70,8 @@ struct __GLXdrawable {
XID drawId;
/*
- ** Either DRAWABLE_PIXMAP or DRAWABLE_WINDOW, copied from pDraw above.
- ** Needed by the resource freer because pDraw might already have been
- ** freed.
+ ** Either GLX_DRAWABLE_PIXMAP, GLX_DRAWABLE_WINDOW or
+ ** GLX_DRAWABLE_PBUFFER.
*/
int type;
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index 3394e58..2ded6aa 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -615,6 +615,7 @@ __glXDRIscreenCreateContext(__GLXscreen
static __GLXdrawable *
__glXDRIscreenCreateDrawable(__GLXscreen *screen,
DrawablePtr pDraw,
+ int type,
XID drawId,
__GLcontextModes *modes)
{
@@ -629,7 +630,8 @@ __glXDRIscreenCreateDrawable(__GLXscreen
memset(private, 0, sizeof *private);
- if (!__glXDrawableInit(&private->base, screen, pDraw, drawId, modes)) {
+ if (!__glXDrawableInit(&private->base, screen,
+ pDraw, type, drawId, modes)) {
xfree(private);
return NULL;
}
diff --git a/GL/glx/glxext.h b/GL/glx/glxext.h
index 8de6434..601bb22 100644
--- a/GL/glx/glxext.h
+++ b/GL/glx/glxext.h
@@ -79,11 +79,6 @@ extern int DoGetFBConfigs(__GLXclientSta
GLboolean do_swap);
extern int DoCreateContext(__GLXclientState *cl, GLXContextID gcId,
GLXContextID shareList, VisualID visual, GLuint screen, GLboolean isDirect);
-extern int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
- GLuint screenNum, XID pixmapId, XID glxpixmapId, CARD32 *attribs,
- CARD32 numAttribs);
-extern int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmapId);
-
extern int DoQueryContext(__GLXclientState *cl, GLXContextID gcId);
extern int DoRender(__GLXclientState *cl, GLbyte *pc, int do_swap);
diff --git a/GL/glx/glxglcore.c b/GL/glx/glxglcore.c
index 679d55c..fd4e57d 100644
--- a/GL/glx/glxglcore.c
+++ b/GL/glx/glxglcore.c
@@ -118,7 +118,7 @@ __glXMesaDrawableSwapBuffers(__GLXdrawab
static __GLXdrawable *
__glXMesaScreenCreateDrawable(__GLXscreen *screen,
- DrawablePtr pDraw,
+ DrawablePtr pDraw, int type,
XID drawId,
__GLcontextModes *modes)
{
@@ -131,7 +131,8 @@ __glXMesaScreenCreateDrawable(__GLXscree
memset(glxPriv, 0, sizeof *glxPriv);
- if (!__glXDrawableInit(&glxPriv->base, screen, pDraw, drawId, modes)) {
+ if (!__glXDrawableInit(&glxPriv->base, screen,
+ pDraw, type, drawId, modes)) {
xfree(glxPriv);
return NULL;
}
diff --git a/GL/glx/glxscreens.h b/GL/glx/glxscreens.h
index d887beb..7b1bbcd 100644
--- a/GL/glx/glxscreens.h
+++ b/GL/glx/glxscreens.h
@@ -72,6 +72,7 @@ struct __GLXscreen {
__GLXdrawable *(*createDrawable)(__GLXscreen *context,
DrawablePtr pDraw,
+ int type,
XID drawId,
__GLcontextModes *modes);
int (*swapInterval) (__GLXdrawable *drawable,
diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c
index df1cb2a..9479a58 100644
--- a/GL/glx/glxutil.c
+++ b/GL/glx/glxutil.c
@@ -139,11 +139,11 @@ __glXUnrefDrawable(__GLXdrawable *glxPri
GLboolean
__glXDrawableInit(__GLXdrawable *drawable,
- __GLXscreen *screen, DrawablePtr pDraw, XID drawId,
- __GLcontextModes *modes)
+ __GLXscreen *screen, DrawablePtr pDraw, int type,
+ XID drawId, __GLcontextModes *modes)
{
- drawable->type = pDraw->type;
drawable->pDraw = pDraw;
+ drawable->type = type;
drawable->drawId = drawId;
drawable->refCount = 1;
drawable->modes = modes;
diff --git a/GL/glx/glxutil.h b/GL/glx/glxutil.h
index 1937ef2..6534c3f 100644
--- a/GL/glx/glxutil.h
+++ b/GL/glx/glxutil.h
@@ -50,7 +50,7 @@ extern void __glXUnrefDrawable(__GLXdraw
extern GLboolean __glXDrawableInit(__GLXdrawable *drawable,
__GLXscreen *screen,
- DrawablePtr pDraw, XID drawID,
+ DrawablePtr pDraw, int type, XID drawID,
__GLcontextModes *modes);
/* context helper routines */
diff --git a/configure.ac b/configure.ac
index 444edfd..59dcde7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -776,7 +776,7 @@ fi
if test "x$GLX" = xyes && ! test "x$MESA_SOURCE" = x; then
PKG_CHECK_MODULES([XLIB], [x11])
- PKG_CHECK_MODULES([GL], [glproto >= 1.4.8])
+ PKG_CHECK_MODULES([GL], [glproto >= 1.4.9])
AC_SUBST(XLIB_CFLAGS)
AC_DEFINE(GLXEXT, 1, [Build GLX extension])
GLX_LIBS='$(top_builddir)/GL/glx/libglx.la $(top_builddir)/GL/mesa/libGLcore.la'
diff-tree 516c181f57367847c3f317f8f8f5cc3211026f4c (from d7ded953c4d263e3dd3374dc03eea19e80c05bc6)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Thu Aug 23 21:40:01 2007 -0400
Add dispatching for GLX_SGIX_pbuffer.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index bf6d6e2..0d576c1 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -1296,6 +1296,15 @@ int __glXDisp_CreatePbuffer(__GLXclientS
return BadRequest;
}
+int __glXDisp_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+ xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
+
+ (void) req;
+
+ return BadRequest;
+}
+
int __glXDisp_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) pc;
@@ -1305,6 +1314,15 @@ int __glXDisp_DestroyPbuffer(__GLXclient
return BadRequest;
}
+__glXDisp_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+ xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) pc;
+
+ (void) req;
+
+ return BadRequest;
+}
+
int __glXDisp_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXChangeDrawableAttributesReq *req =
@@ -1315,6 +1333,16 @@ int __glXDisp_ChangeDrawableAttributes(_
return BadRequest;
}
+int __glXDisp_ChangeDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+ xGLXChangeDrawableAttributesSGIXReq *req =
+ (xGLXChangeDrawableAttributesSGIXReq *)pc;
+
+ (void) req;
+
+ return BadRequest;
+}
+
int __glXDisp_CreateWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
@@ -1611,22 +1639,18 @@ DoGetDrawableAttributes(__GLXclientState
return Success;
}
-int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
+int __glXDisp_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
- xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc;
- CARD32 *data;
- XID drawable;
-
- data = (CARD32 *) (req + 1);
- drawable = data[0];
+ xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
- return DoGetDrawableAttributes(cl, drawable);
+ return DoGetDrawableAttributes(cl, req->drawable);
}
-int __glXDisp_GetDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
+int __glXDisp_GetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc)
{
- xGLXGetDrawableAttributesReq *req = (xGLXGetDrawableAttributesReq *)pc;
-
+ xGLXGetDrawableAttributesSGIXReq *req =
+ (xGLXGetDrawableAttributesSGIXReq *)pc;
+
return DoGetDrawableAttributes(cl, req->drawable);
}
diff --git a/GL/glx/glxcmdsswap.c b/GL/glx/glxcmdsswap.c
index 12bc030..3f600c1 100644
--- a/GL/glx/glxcmdsswap.c
+++ b/GL/glx/glxcmdsswap.c
@@ -343,6 +343,15 @@ int __glXDispSwap_CreatePbuffer(__GLXcli
return BadRequest;
}
+int __glXDispSwap_CreateGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+ xGLXCreateGLXPbufferSGIXReq *req = (xGLXCreateGLXPbufferSGIXReq *) pc;
+
+ (void) req;
+
+ return BadRequest;
+}
+
int __glXDispSwap_DestroyPbuffer(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPbufferReq *req = (xGLXDestroyPbufferReq *) req;
@@ -350,6 +359,13 @@ int __glXDispSwap_DestroyPbuffer(__GLXcl
return BadRequest;
}
+int __glXDispSwap_DestroyGLXPbufferSGIX(__GLXclientState *cl, GLbyte *pc)
+{
+ xGLXDestroyGLXPbufferSGIXReq *req = (xGLXDestroyGLXPbufferSGIXReq *) req;
+
+ return BadRequest;
+}
+
int __glXDispSwap_ChangeDrawableAttributes(__GLXclientState *cl, GLbyte *pc)
{
xGLXChangeDrawableAttributesReq *req =
@@ -358,6 +374,15 @@ int __glXDispSwap_ChangeDrawableAttribut
return BadRequest;
}
+int __glXDispSwap_ChangeDrawableAttributesSGIX(__GLXclientState *cl,
+ GLbyte *pc)
+{
+ xGLXChangeDrawableAttributesSGIXReq *req =
+ (xGLXChangeDrawableAttributesSGIXReq *) req;
+
+ return BadRequest;
+}
+
int __glXDispSwap_CreateWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
diff --git a/GL/glx/indirect_dispatch.h b/GL/glx/indirect_dispatch.h
index 24f4bed..bb39638 100644
--- a/GL/glx/indirect_dispatch.h
+++ b/GL/glx/indirect_dispatch.h
@@ -207,6 +207,8 @@ extern HIDDEN void __glXDisp_TexCoord2iv
extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
+extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
@@ -293,8 +295,8 @@ extern HIDDEN void __glXDisp_ClearIndex(
extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
-extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
+extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
@@ -371,14 +373,16 @@ extern HIDDEN void __glXDisp_ProgramName
extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
+extern HIDDEN int __glXDisp_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_CreateGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
-extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
+extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
@@ -619,8 +623,8 @@ extern HIDDEN int __glXDisp_PixelStorei(
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
-extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
+extern HIDDEN int __glXDisp_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_DestroyGLXPbufferSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
@@ -669,6 +673,8 @@ extern HIDDEN void __glXDisp_Lighti(GLby
extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDisp_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
+extern HIDDEN int __glXDispSwap_ChangeDrawableAttributesSGIX(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_CreatePbuffer(struct __GLXclientStateRec *, GLbyte *);
@@ -751,8 +757,8 @@ extern HIDDEN void __glXDisp_PixelTransf
extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
-extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
-extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
+extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
+extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
diff --git a/GL/glx/indirect_size_get.c b/GL/glx/indirect_size_get.c
index f29ae47..9285714 100644
--- a/GL/glx/indirect_size_get.c
+++ b/GL/glx/indirect_size_get.c
@@ -697,6 +697,7 @@ __glGetBooleanv_size(GLenum e)
case GL_MATRIX_INDEX_ARRAY_SIZE_ARB:
case GL_MATRIX_INDEX_ARRAY_TYPE_ARB:
case GL_MATRIX_INDEX_ARRAY_STRIDE_ARB:
+ case GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT:
case GL_POINT_SPRITE_ARB:
/* case GL_POINT_SPRITE_NV:*/
case GL_POINT_SPRITE_R_MODE_NV:
@@ -704,8 +705,11 @@ __glGetBooleanv_size(GLenum e)
case GL_MAX_TEXTURE_COORDS_ARB:
case GL_MAX_TEXTURE_IMAGE_UNITS_ARB:
case GL_DEPTH_BOUNDS_TEST_EXT:
+ case GL_MAX_ARRAY_TEXTURE_LAYERS_EXT:
case GL_STENCIL_TEST_TWO_SIDE_EXT:
case GL_ACTIVE_STENCIL_FACE_EXT:
+ case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
+ case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
case GL_RASTER_POSITION_UNCLIPPED_IBM:
return 1;
case GL_SMOOTH_POINT_SIZE_RANGE:
diff --git a/GL/glx/indirect_table.c b/GL/glx/indirect_table.c
index 9d0383c..3da1f43 100644
--- a/GL/glx/indirect_table.c
+++ b/GL/glx/indirect_table.c
@@ -1575,9 +1575,9 @@ static const void *VendorPriv_function_t
/* [ 92] = 65540 */ {__glXDisp_GetFBConfigsSGIX, __glXDispSwap_GetFBConfigsSGIX},
/* [ 93] = 65541 */ {__glXDisp_CreateContextWithConfigSGIX, __glXDispSwap_CreateContextWithConfigSGIX},
/* [ 94] = 65542 */ {__glXDisp_CreateGLXPixmapWithConfigSGIX, __glXDispSwap_CreateGLXPixmapWithConfigSGIX},
- /* [ 95] = 65543 */ {NULL, NULL},
- /* [ 96] = 65544 */ {NULL, NULL},
- /* [ 97] = 65545 */ {NULL, NULL},
+ /* [ 95] = 65543 */ {__glXDisp_CreateGLXPbufferSGIX, __glXDispSwap_CreateGLXPbufferSGIX},
+ /* [ 96] = 65544 */ {__glXDisp_DestroyGLXPbufferSGIX, __glXDispSwap_DestroyGLXPbufferSGIX},
+ /* [ 97] = 65545 */ {__glXDisp_ChangeDrawableAttributesSGIX, __glXDispSwap_ChangeDrawableAttributesSGIX},
/* [ 98] = 65546 */ {__glXDisp_GetDrawableAttributesSGIX, __glXDispSwap_GetDrawableAttributesSGIX},
/* [ 99] = 65547 */ {NULL, NULL},
/* [ 100] = 65548 */ {NULL, NULL},
diff-tree d7ded953c4d263e3dd3374dc03eea19e80c05bc6 (from 2b0847c7aaf95b6b10f062dfff601032b2430a9b)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Thu Aug 23 19:07:52 2007 -0400
Implment GLXPixmaps.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index 732b135..bf6d6e2 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -425,108 +425,79 @@ int __glXDisp_MakeCurrentReadSGI(__GLXcl
*
* \param glxc Associated GLX context.
* \param drawId ID of the drawable.
- * \param ppDraw Location to store the pointer to the drawable.
- * \param ppPixmap Location to store the pointer to the pixmap.
* \param client Pointer to the client state.
- * \return Zero is returned on success. Otherwise a GLX / X11 protocol error
- * is returned.
+ * \return the __GLXdrawable is returned on success. Otherwise NULL.
*
* \notes This function will need some modification when support pbuffers
* is added.
*/
-static int GetDrawableOrPixmap( __GLXcontext *glxc, GLXDrawable drawId,
- __GLXdrawable **ppGlxDraw,
- __GLXpixmap **ppPixmap,
- ClientPtr client )
+static __GLXdrawable *
+__glXGetDrawable(__GLXcontext *glxc, GLXDrawable drawId, ClientPtr client,
+ int *error)
{
DrawablePtr pDraw;
__GLcontextModes *modes;
__GLXdrawable *pGlxDraw;
- __GLXpixmap *drawPixmap = NULL;
+ VisualID vid;
int rc;
- /* This is the GLX 1.3 case - the client passes in a GLXWindow and
- * we just return the __GLXdrawable. The first time a GLXPixmap
- * comes in, it doesn't have a corresponding __GLXdrawable, so it
- * falls through to the else-case below, but after that it'll have
- * a __GLXdrawable and we'll handle it here. */
+ /* This is the GLX 1.3 case - the client passes in a GLXWindow or
+ * GLXPixmap and we just return the __GLXdrawable. */
pGlxDraw = (__GLXdrawable *) LookupIDByType(drawId, __glXDrawableRes);
if (pGlxDraw != NULL) {
if (glxc != NULL && pGlxDraw->modes != glxc->modes) {
client->errorValue = drawId;
- return BadMatch;
+ *error = BadMatch;
+ return NULL;
}
- *ppGlxDraw = pGlxDraw;
- *ppPixmap = pGlxDraw->pGlxPixmap;
- return Success;
+ return pGlxDraw;
}
- /* The drawId wasn't a GLXWindow, so presumably it's a regular X
- * window. In that case, we create a shadow GLXWindow for it on
+ /* The drawId wasn't a GLX drawable, so presumably it's a regular
+ * X window. In that case, we create a shadow GLXWindow for it on
* demand here for pre GLX 1.3 compatibility and use the X Window
* XID as its GLXWindow XID. The client can't explicitly create a
* GLXWindow with the same XID as an X Window, so we wont get any
* resource ID clashes. Effectively, the X Window is now also a
* GLXWindow. */
- rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixUnknownAccess);
- if (rc == Success) {
- if (pDraw->type == DRAWABLE_WINDOW) {
- VisualID vid = wVisual((WindowPtr)pDraw);
- modes = _gl_context_modes_find_visual(glxc->pGlxScreen->modes,
- vid);
- } else {
- /*
- ** An X Pixmap is not allowed as a parameter (a GLX Pixmap
- ** is, but it must first be created with glxCreateGLXPixmap).
- */
- client->errorValue = drawId;
- return __glXError(GLXBadDrawable);
- }
- } else {
- drawPixmap = (__GLXpixmap *) LookupIDByType(drawId, __glXPixmapRes);
- if (drawPixmap) {
- pDraw = drawPixmap->pDraw;
- modes = drawPixmap->modes;
- } else {
- /*
- ** Drawable is neither a Window nor a GLXPixmap.
- */
- client->errorValue = drawId;
- return __glXError(GLXBadDrawable);
- }
+ rc = dixLookupDrawable(&pDraw, drawId, client, 0, DixUnknownAccess);
+ if (rc != Success || pDraw->type != DRAWABLE_WINDOW) {
+ client->errorValue = drawId;
+ *error = __glXError(GLXBadDrawable);
+ return NULL;
}
/* If we're not given a context, don't create the __GLXdrawable */
if (glxc == NULL) {
- *ppPixmap = NULL;
- *ppGlxDraw = NULL;
- return Success;
+ *error = __glXError(GLXBadDrawable);
+ return NULL;
}
- /* We're binding an X Window or a GLX Pixmap for the first time
- * and need to create a GLX drawable for it. First check that the
- * drawable screen and fbconfig matches the context ditto. */
+ vid = wVisual((WindowPtr)pDraw);
+ modes = _gl_context_modes_find_visual(glxc->pGlxScreen->modes, vid);
+
+ /* We're binding an X Window for the first time and need to create
+ * a GLX drawable for it. First check that the drawable screen
+ * and fbconfig matches the context ditto. */
if (pDraw->pScreen != glxc->pScreen || modes != glxc->modes) {
client->errorValue = drawId;
- return BadMatch;
+ *error = BadMatch;
+ return NULL;
}
- pGlxDraw =
- glxc->pGlxScreen->createDrawable(glxc->pGlxScreen,
- pDraw, drawId, modes);
+ pGlxDraw = glxc->pGlxScreen->createDrawable(glxc->pGlxScreen,
+ pDraw, drawId, modes);
/* since we are creating the drawablePrivate, drawId should be new */
if (!AddResource(drawId, __glXDrawableRes, pGlxDraw)) {
pGlxDraw->destroy (pGlxDraw);
- return BadAlloc;
+ *error = BadAlloc;
+ return NULL;
}
- *ppPixmap = drawPixmap;
- *ppGlxDraw = pGlxDraw;
-
- return 0;
+ return pGlxDraw;
}
@@ -536,8 +507,6 @@ int DoMakeCurrent( __GLXclientState *cl,
{
ClientPtr client = cl->client;
xGLXMakeCurrentReply reply;
- __GLXpixmap *drawPixmap = NULL;
- __GLXpixmap *readPixmap = NULL;
__GLXcontext *glxc, *prevglxc;
__GLXdrawable *drawPriv = NULL;
__GLXdrawable *readPriv = NULL;
@@ -595,21 +564,13 @@ int DoMakeCurrent( __GLXclientState *cl,
assert( drawId != None );
assert( readId != None );
- status = GetDrawableOrPixmap(glxc, drawId, &drawPriv, &drawPixmap,
- client);
- if ( status != 0 ) {
+ drawPriv = __glXGetDrawable(glxc, drawId, client, &status);
+ if (drawPriv == NULL)
return status;
- }
- if ( readId != drawId ) {
- status = GetDrawableOrPixmap(glxc, readId, &readPriv, &readPixmap,
- client);
- if ( status != 0 ) {
- return status;
- }
- } else {
- readPriv = drawPriv;
- }
+ readPriv = __glXGetDrawable(glxc, readId, client, &status);
+ if (readPriv == NULL)
+ return status;
} else {
/* Switching to no context. Ignore new drawable. */
@@ -671,42 +632,6 @@ int DoMakeCurrent( __GLXclientState *cl,
}
if (prevglxc) {
- if (prevglxc->drawPixmap) {
- if (prevglxc->readPixmap &&
- prevglxc->drawPixmap != prevglxc->readPixmap) {
- /*
- ** The previous drawable was a glx pixmap, release it.
- */
- prevglxc->readPixmap->refcnt--;
- if (!prevglxc->readPixmap->idExists &&
- !prevglxc->readPixmap->refcnt) {
- PixmapPtr pPixmap = (PixmapPtr) prevglxc->readPixmap->pDraw;
- /*
- ** The DestroyPixmap routine should decrement the
- ** refcount of the X pixmap and free only if it's zero.
- */
- (*prevglxc->readPixmap->pScreen->DestroyPixmap)(pPixmap);
- xfree(prevglxc->readPixmap);
- }
- }
-
- /*
- ** The previous drawable was a glx pixmap, release it.
- */
- prevglxc->drawPixmap->refcnt--;
- if (!prevglxc->drawPixmap->idExists &&
- !prevglxc->drawPixmap->refcnt) {
- PixmapPtr pPixmap = (PixmapPtr) prevglxc->drawPixmap->pDraw;
- /*
- ** The DestroyPixmap routine should decrement the
- ** refcount of the X pixmap and free only if it's zero.
- */
- (*prevglxc->drawPixmap->pScreen->DestroyPixmap)(pPixmap);
- xfree(prevglxc->drawPixmap);
- }
-
- prevglxc->drawPixmap = NULL;
- }
ChangeCurrentContext(cl, glxc, tag);
StopUsingContext(prevglxc);
} else {
@@ -714,16 +639,6 @@ int DoMakeCurrent( __GLXclientState *cl,
}
if (glxc) {
- if (drawPixmap) {
- drawPixmap->refcnt++;
- glxc->drawPixmap = drawPixmap;
- }
-
- if (readPixmap && (readPixmap != drawPixmap)) {
- readPixmap->refcnt++;
- glxc->readPixmap = readPixmap;
- }
-
StartUsingContext(cl, glxc);
reply.contextTag = tag;
} else {
@@ -1210,31 +1125,30 @@ int __glXDisp_GetFBConfigsSGIX(__GLXclie
return DoGetFBConfigs( cl, req->screen, GL_FALSE );
}
-static int ValidateCreateDrawable(ClientPtr client,
- int screenNum, XID fbconfigId,
- XID drawablId, XID glxDrawableId,
- int type, __GLcontextModes **modes,
- DrawablePtr *ppDraw)
+static int
+DoCreateGLXDrawable(ClientPtr client, int screenNum, XID fbconfigId,
+ XID drawableId, XID glxDrawableId, int type)
{
DrawablePtr pDraw;
ScreenPtr pScreen;
VisualPtr pVisual;
__GLXscreen *pGlxScreen;
+ __GLXdrawable *pGlxDraw;
+ __GLcontextModes *modes;
int i, rc;
LEGAL_NEW_RESOURCE(glxDrawableId, client);
- rc = dixLookupDrawable(&pDraw, drawablId, client, 0, DixUnknownAccess);
+ rc = dixLookupDrawable(&pDraw, drawableId, client, 0, DixUnknownAccess);
if (rc != Success || pDraw->type != type) {
- client->errorValue = drawablId;
+ client->errorValue = drawableId;
return type == DRAWABLE_WINDOW ? BadWindow : BadPixmap;
}
/* Check if screen of the fbconfig matches screen of drawable. */
pScreen = pDraw->pScreen;
- if (screenNum != pScreen->myNum) {
+ if (screenNum != pScreen->myNum)
return BadMatch;
- }
/* If this fbconfig has a corresponding VisualRec the number of
* planes must match the drawable depth. */
@@ -1246,55 +1160,39 @@ static int ValidateCreateDrawable(Client
/* Get configuration of the visual. */
pGlxScreen = glxGetScreen(pScreen);
- *modes = _gl_context_modes_find_visual(pGlxScreen->modes, fbconfigId);
- if (*modes == NULL) {
+ modes = _gl_context_modes_find_visual(pGlxScreen->modes, fbconfigId);
+ if (modes == NULL) {
/* Visual not support on this screen by this OpenGL implementation. */
client->errorValue = fbconfigId;
return BadValue;
}
- *ppDraw = pDraw;
+ /* FIXME: We need to check that the window visual is compatible
+ * with the specified fbconfig. */
+ pGlxDraw = pGlxScreen->createDrawable(pGlxScreen, pDraw,
+ glxDrawableId, modes);
+ if (pGlxDraw == NULL)
+ return BadAlloc;
+
+ if (!AddResource(glxDrawableId, __glXDrawableRes, pGlxDraw)) {
+ pGlxDraw->destroy (pGlxDraw);
+ return BadAlloc;
+ }
+
+ if (type == DRAWABLE_PIXMAP)
+ ((PixmapPtr) pDraw)->refcnt++;
return Success;
}
-/*
-** Create a GLX Pixmap from an X Pixmap.
-*/
-int DoCreateGLXPixmap(__GLXclientState *cl, XID fbconfigId,
- GLuint screenNum, XID pixmapId, XID glxPixmapId,
- CARD32 *attribs, CARD32 numAttribs)
+static void
+determineTextureTarget(XID glxDrawableID, CARD32 *attribs, CARD32 numAttribs)
{
- ClientPtr client = cl->client;
- DrawablePtr pDraw;
- __GLXpixmap *pGlxPixmap;
- __GLcontextModes *modes;
GLenum target = 0;
- int retval, i;
-
- retval = ValidateCreateDrawable (client, screenNum, fbconfigId,
- pixmapId, glxPixmapId,
- DRAWABLE_PIXMAP, &modes, &pDraw);
- if (retval != Success)
- return retval;
-
- pGlxPixmap = (__GLXpixmap *) xalloc(sizeof(__GLXpixmap));
- if (!pGlxPixmap) {
- return BadAlloc;
- }
- if (!(AddResource(glxPixmapId, __glXPixmapRes, pGlxPixmap))) {
- return BadAlloc;
- }
- pGlxPixmap->pDraw = pDraw;
- pGlxPixmap->pGlxScreen = glxGetScreen(pDraw->pScreen);
- pGlxPixmap->pScreen = pDraw->pScreen;
- pGlxPixmap->idExists = True;
-#ifdef XF86DRI
- pGlxPixmap->pDamage = NULL;
-#endif
- pGlxPixmap->refcnt = 0;
+ int i;
+ __GLXdrawable *pGlxDraw;
- pGlxPixmap->modes = modes;
+ pGlxDraw = LookupIDByType(glxDrawableID, __glXDrawableRes);
for (i = 0; i < numAttribs; i++) {
if (attribs[2 * i] == GLX_TEXTURE_TARGET_EXT) {
@@ -1308,63 +1206,69 @@ int DoCreateGLXPixmap(__GLXclientState *
}
}
}
-
+
if (!target) {
- int w = pDraw->width, h = pDraw->height;
-
+ int w = pGlxDraw->pDraw->width, h = pGlxDraw->pDraw->height;
+
if (h & (h - 1) || w & (w - 1))
target = GL_TEXTURE_RECTANGLE_ARB;
else
target = GL_TEXTURE_2D;
}
- pGlxPixmap->target = target;
-
- /*
- ** Bump the ref count on the X pixmap so it won't disappear.
- */
- ((PixmapPtr) pDraw)->refcnt++;
-
- return Success;
+ pGlxDraw->target = target;
}
int __glXDisp_CreateGLXPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapReq *req = (xGLXCreateGLXPixmapReq *) pc;
- return DoCreateGLXPixmap( cl, req->visual, req->screen,
- req->pixmap, req->glxpixmap, NULL, 0 );
+
+ return DoCreateGLXDrawable(cl->client, req->screen, req->visual,
+ req->pixmap, req->glxpixmap, DRAWABLE_PIXMAP);
}
int __glXDisp_CreatePixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreatePixmapReq *req = (xGLXCreatePixmapReq *) pc;
- return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
- req->pixmap, req->glxpixmap,
- (CARD32*)(req + 1),
- req->numAttribs );
+ int err;
+
+ err = DoCreateGLXDrawable(cl->client, req->screen, req->fbconfig,
+ req->pixmap, req->glxpixmap, DRAWABLE_PIXMAP);
+ if (err != Success)
+ return err;
+
+ determineTextureTarget(req->glxpixmap,
+ (CARD32*) (req + 1), req->numAttribs);
+
+ return Success;
}
int __glXDisp_CreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc)
{
xGLXCreateGLXPixmapWithConfigSGIXReq *req =
(xGLXCreateGLXPixmapWithConfigSGIXReq *) pc;
- return DoCreateGLXPixmap( cl, req->fbconfig, req->screen,
- req->pixmap, req->glxpixmap, NULL, 0 );
+
+ return DoCreateGLXDrawable(cl->client, req->screen, req->fbconfig,
+ req->pixmap, req->glxpixmap, DRAWABLE_PIXMAP);
}
-int DoDestroyPixmap(__GLXclientState *cl, XID glxpixmap)
+static int DoDestroyDrawable(__GLXclientState *cl, XID glxdrawable, int type)
{
ClientPtr client = cl->client;
+ __GLXdrawable *pGlxDraw;
+ int error;
/*
- ** Check if it's a valid GLX pixmap.
+ ** Check it's the right type of drawable.
*/
- if (!LookupIDByType(glxpixmap, __glXPixmapRes)) {
- client->errorValue = glxpixmap;
- return __glXError(GLXBadPixmap);
+ pGlxDraw = LookupIDByType(glxdrawable, __glXDrawableRes);
+ if (pGlxDraw == NULL || pGlxDraw->type != type) {
+ client->errorValue = glxdrawable;
+ error = type == DRAWABLE_WINDOW ? GLXBadWindow : GLXBadDrawable;
+ return __glXError(error);
}
- FreeResource(glxpixmap, FALSE);
+ FreeResource(glxdrawable, FALSE);
return Success;
}
@@ -1373,14 +1277,14 @@ int __glXDisp_DestroyGLXPixmap(__GLXclie
{
xGLXDestroyGLXPixmapReq *req = (xGLXDestroyGLXPixmapReq *) pc;
- return DoDestroyPixmap(cl, req->glxpixmap);
+ return DoDestroyDrawable(cl, req->glxpixmap, DRAWABLE_PIXMAP);
}
int __glXDisp_DestroyPixmap(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyPixmapReq *req = (xGLXDestroyPixmapReq *) pc;
- return DoDestroyPixmap(cl, req->glxpixmap);
+ return DoDestroyDrawable(cl, req->glxpixmap, DRAWABLE_PIXMAP);
}
int __glXDisp_CreatePbuffer(__GLXclientState *cl, GLbyte *pc)
@@ -1415,49 +1319,16 @@ int __glXDisp_CreateWindow(__GLXclientSt
{
xGLXCreateWindowReq *req = (xGLXCreateWindowReq *) pc;
ClientPtr client = cl->client;
- DrawablePtr pDraw;
- __GLXdrawable *glxPriv;
- __GLXscreen *screen;
- __GLcontextModes *modes;
- int retval;
-
- retval = ValidateCreateDrawable (client, req->screen, req->fbconfig,
- req->window, req->glxwindow,
- DRAWABLE_WINDOW, &modes, &pDraw);
- if (retval != Success)
- return retval;
-
- /* FIXME: We need to check that the window visual is compatible
- * with the specified fbconfig. */
- screen = glxGetScreen(screenInfo.screens[req->screen]);
- glxPriv = screen->createDrawable(screen, pDraw, req->glxwindow, modes);
- if (glxPriv == NULL)
- return BadAlloc;
-
- if (!AddResource(req->glxwindow, __glXDrawableRes, glxPriv)) {
- glxPriv->destroy (glxPriv);
- return BadAlloc;
- }
-
- return Success;
+ return DoCreateGLXDrawable(client, req->screen, req->fbconfig,
+ req->window, req->glxwindow, DRAWABLE_WINDOW);
}
int __glXDisp_DestroyWindow(__GLXclientState *cl, GLbyte *pc)
{
xGLXDestroyWindowReq *req = (xGLXDestroyWindowReq *) pc;
- ClientPtr client = cl->client;
-
- /*
- ** Check if it's a valid GLX window.
- */
- if (!LookupIDByType(req->glxwindow, __glXDrawableRes)) {
- client->errorValue = req->glxwindow;
- return __glXError(GLXBadWindow);
- }
- FreeResource(req->glxwindow, FALSE);
- return Success;
+ return DoDestroyDrawable(cl, req->glxwindow, DRAWABLE_WINDOW);
}
@@ -1476,7 +1347,6 @@ int __glXDisp_SwapBuffers(__GLXclientSta
XID drawId = req->drawable;
__GLXcontext *glxc = NULL;
__GLXdrawable *pGlxDraw;
- __GLXpixmap *pPixmap;
int error;
if (tag) {
@@ -1501,11 +1371,11 @@ int __glXDisp_SwapBuffers(__GLXclientSta
}
}
- error = GetDrawableOrPixmap(glxc, drawId, &pGlxDraw, &pPixmap, client);
- if (error != Success)
+ pGlxDraw = __glXGetDrawable(glxc, drawId, client, &error);
+ if (pGlxDraw == NULL)
return error;
- if (pGlxDraw != NULL && pGlxDraw->type == DRAWABLE_WINDOW &&
+ if (pGlxDraw->type == DRAWABLE_WINDOW &&
(*pGlxDraw->swapBuffers)(pGlxDraw) == GL_FALSE)
return __glXError(GLXBadDrawable);
@@ -1576,8 +1446,8 @@ int __glXDisp_BindTexImageEXT(__GLXclien
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
ClientPtr client = cl->client;
- __GLXpixmap *pGlxPixmap;
__GLXcontext *context;
+ __GLXdrawable *pGlxDraw;
GLXDrawable drawId;
int buffer;
int error;
@@ -1594,8 +1464,8 @@ int __glXDisp_BindTexImageEXT(__GLXclien
if (!context)
return error;
- pGlxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes);
- if (!pGlxPixmap) {
+ pGlxDraw = __glXGetDrawable(NULL, drawId, client, &error);
+ if (!pGlxDraw || pGlxDraw->type != DRAWABLE_PIXMAP) {
client->errorValue = drawId;
return __glXError(GLXBadPixmap);
}
@@ -1605,14 +1475,14 @@ int __glXDisp_BindTexImageEXT(__GLXclien
return context->textureFromPixmap->bindTexImage(context,
buffer,
- pGlxPixmap);
+ pGlxDraw);
}
int __glXDisp_ReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc)
{
xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc;
ClientPtr client = cl->client;
- __GLXpixmap *pGlxPixmap;
+ __GLXdrawable *pGlxDraw;
__GLXcontext *context;
GLXDrawable drawId;
int buffer;
@@ -1627,10 +1497,10 @@ int __glXDisp_ReleaseTexImageEXT(__GLXcl
if (!context)
return error;
- pGlxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes);
- if (!pGlxPixmap) {
+ pGlxDraw = __glXGetDrawable(NULL, drawId, client, &error);
+ if (error != Success || pGlxDraw->type != DRAWABLE_PIXMAP) {
client->errorValue = drawId;
- return __glXError(GLXBadDrawable);
+ return error;
}
if (!context->textureFromPixmap)
@@ -1638,7 +1508,7 @@ int __glXDisp_ReleaseTexImageEXT(__GLXcl
return context->textureFromPixmap->releaseTexImage(context,
buffer,
- pGlxPixmap);
+ pGlxDraw);
}
int __glXDisp_CopySubBufferMESA(__GLXclientState *cl, GLbyte *pc)
@@ -1647,7 +1517,6 @@ int __glXDisp_CopySubBufferMESA(__GLXcli
GLXContextTag tag = req->contextTag;
__GLXcontext *glxc = NULL;
__GLXdrawable *pGlxDraw;
- __GLXpixmap *pPixmap;
ClientPtr client = cl->client;
GLXDrawable drawId;
int error;
@@ -1686,7 +1555,7 @@ int __glXDisp_CopySubBufferMESA(__GLXcli
}
}
- error = GetDrawableOrPixmap(glxc, drawId, &pGlxDraw, &pPixmap, client);
+ pGlxDraw = __glXGetDrawable(glxc, drawId, client, &error);
if (error != Success)
return error;
@@ -1707,15 +1576,15 @@ static int
DoGetDrawableAttributes(__GLXclientState *cl, XID drawId)
{
ClientPtr client = cl->client;
- __GLXpixmap *glxPixmap;
xGLXGetDrawableAttributesReply reply;
+ __GLXdrawable *pGlxDraw;
CARD32 attributes[4];
- int numAttribs;
+ int numAttribs, error;
- glxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes);
- if (!glxPixmap) {
+ pGlxDraw = __glXGetDrawable(NULL, drawId, client, &error);
+ if (!pGlxDraw) {
client->errorValue = drawId;
- return __glXError(GLXBadPixmap);
+ return error;
}
numAttribs = 2;
@@ -1725,7 +1594,7 @@ DoGetDrawableAttributes(__GLXclientState
reply.numAttribs = numAttribs;
attributes[0] = GLX_TEXTURE_TARGET_EXT;
- attributes[1] = glxPixmap->target == GL_TEXTURE_2D ? GLX_TEXTURE_2D_EXT :
+ attributes[1] = pGlxDraw->target == GL_TEXTURE_2D ? GLX_TEXTURE_2D_EXT :
GLX_TEXTURE_RECTANGLE_EXT;
attributes[2] = GLX_Y_INVERTED_EXT;
attributes[3] = GL_FALSE;
diff --git a/GL/glx/glxcontext.h b/GL/glx/glxcontext.h
index eb10ee2..7122647 100644
--- a/GL/glx/glxcontext.h
+++ b/GL/glx/glxcontext.h
@@ -44,12 +44,12 @@
typedef struct __GLXtextureFromPixmap __GLXtextureFromPixmap;
struct __GLXtextureFromPixmap {
- int (*bindTexImage) (__GLXcontext *baseContext,
- int buffer,
- __GLXpixmap *pixmap);
- int (*releaseTexImage) (__GLXcontext *baseContext,
- int buffer,
- __GLXpixmap *pixmap);
+ int (*bindTexImage) (__GLXcontext *baseContext,
+ int buffer,
+ __GLXdrawable *pixmap);
+ int (*releaseTexImage) (__GLXcontext *baseContext,
+ int buffer,
+ __GLXdrawable *pixmap);
};
@@ -152,12 +152,6 @@ struct __GLXcontext {
GLint selectBufSize; /* number of elements allocated */
/*
- ** Set only if current drawable is a glx pixmap.
- */
- __GLXpixmap *drawPixmap;
- __GLXpixmap *readPixmap;
-
- /*
** The drawable private this context is bound to
*/
__GLXdrawable *drawPriv;
diff --git a/GL/glx/glxdrawable.h b/GL/glx/glxdrawable.h
index b7ecad9..5fdcf95 100644
--- a/GL/glx/glxdrawable.h
+++ b/GL/glx/glxdrawable.h
@@ -46,23 +46,6 @@
#include <GL/internal/dri_interface.h>
#endif
-typedef struct {
-
- DrawablePtr pDraw;
- __GLcontextModes *modes;
- __GLXscreen *pGlxScreen;
- ScreenPtr pScreen;
- Bool idExists;
- int refcnt;
- GLenum target;
-#ifdef XF86DRI
- DamagePtr pDamage;
- __DRIcontext *pDRICtx;
- GLint texname;
- unsigned long offset;
-#endif
-} __GLXpixmap;
-
struct __GLXdrawable {
void (*destroy)(__GLXdrawable *private);
GLboolean (*resize)(__GLXdrawable *private);
@@ -78,7 +61,6 @@ struct __GLXdrawable {
DrawablePtr pDraw;
XID drawId;
- __GLXpixmap *pGlxPixmap;
/*
** Either DRAWABLE_PIXMAP or DRAWABLE_WINDOW, copied from pDraw above.
@@ -105,6 +87,8 @@ struct __GLXdrawable {
** reference count
*/
int refCount;
+
+ GLenum target;
};
#endif /* !__GLX_drawable_h__ */
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index ae74311..3394e58 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -59,6 +59,9 @@
#include "dispatch.h"
#include "extension_string.h"
+#define containerOf(ptr, type, member) \
+ (type *)( (char *)ptr - offsetof(type,member) )
+
typedef struct __GLXDRIscreen __GLXDRIscreen;
typedef struct __GLXDRIcontext __GLXDRIcontext;
typedef struct __GLXDRIdrawable __GLXDRIdrawable;
@@ -73,12 +76,14 @@ struct __GLXDRIscreen {
__DRIcopySubBufferExtension *copySubBuffer;
__DRIswapControlExtension *swapControl;
- __DRItexOffsetExtension *texOffset;
+#ifdef __DRI_TEX_OFFSET
+ __DRItexOffsetExtension *texOffset;
DRITexOffsetStartProcPtr texOffsetStart;
DRITexOffsetFinishProcPtr texOffsetFinish;
- __GLXpixmap* texOffsetOverride[16];
+ __GLXDRIdrawable *texOffsetOverride[16];
GLuint lastTexOffsetOverride;
+#endif
unsigned char glx_enable_bits[__GLX_EXT_BYTES];
};
@@ -92,6 +97,14 @@ struct __GLXDRIcontext {
struct __GLXDRIdrawable {
__GLXdrawable base;
__DRIdrawable driDrawable;
+
+ /* Pulled in from old __GLXpixmap */
+#ifdef __DRI_TEX_OFFSET
+ GLint texname;
+ __GLXDRIcontext *ctx;
+ unsigned long offset;
+ DamagePtr pDamage;
+#endif
};
static const char CREATE_NEW_SCREEN_FUNC[] = __DRI_CREATE_NEW_SCREEN_STRING;
@@ -107,15 +120,15 @@ __glXDRIleaveServer(GLboolean rendering)
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
- __GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+ __GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
int j;
for (j = 0; j < lastOverride; j++) {
- __GLXpixmap *pGlxPix = texOffsetOverride[j];
+ __GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
if (pGlxPix && pGlxPix->texname) {
pGlxPix->offset =
- screen->texOffsetStart((PixmapPtr)pGlxPix->pDraw);
+ screen->texOffsetStart((PixmapPtr)pGlxPix->base.pDraw);
}
}
}
@@ -129,18 +142,18 @@ __glXDRIleaveServer(GLboolean rendering)
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
- __GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+ __GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
int j;
for (j = 0; j < lastOverride; j++) {
- __GLXpixmap *pGlxPix = texOffsetOverride[j];
+ __GLXDRIdrawable *pGlxPix = texOffsetOverride[j];
if (pGlxPix && pGlxPix->texname) {
- screen->texOffset->setTexOffset(pGlxPix->pDRICtx,
+ screen->texOffset->setTexOffset(&pGlxPix->ctx->driContext,
pGlxPix->texname,
pGlxPix->offset,
- pGlxPix->pDraw->depth,
- ((PixmapPtr)pGlxPix->pDraw)->devKind);
+ pGlxPix->base.pDraw->depth,
+ ((PixmapPtr)pGlxPix->base.pDraw)->devKind);
}
}
}
@@ -321,14 +334,17 @@ glxFillAlphaChannel (PixmapPtr pixmap, i
static int
__glXDRIbindTexImage(__GLXcontext *baseContext,
int buffer,
- __GLXpixmap *glxPixmap)
+ __GLXdrawable *glxPixmap)
{
RegionPtr pRegion = NULL;
PixmapPtr pixmap;
int bpp, override = 0, texname;
GLenum format, type;
- ScreenPtr pScreen = glxPixmap->pScreen;
- __GLXDRIscreen * const screen = (__GLXDRIscreen *) glxGetScreen(pScreen);
+ ScreenPtr pScreen = glxPixmap->pDraw->pScreen;
+ __GLXDRIdrawable *driDraw =
+ containerOf(glxPixmap, __GLXDRIdrawable, base);
+ __GLXDRIscreen * const screen =
+ (__GLXDRIscreen *) glxGetScreen(pScreen);
CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
GL_TEXTURE_BINDING_2D :
@@ -341,11 +357,11 @@ __glXDRIbindTexImage(__GLXcontext *baseC
pixmap = (PixmapPtr) glxPixmap->pDraw;
if (screen->texOffsetStart && screen->texOffset) {
- __GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+ __GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
int i, firstEmpty = 16;
for (i = 0; i < 16; i++) {
- if (texOffsetOverride[i] == glxPixmap)
+ if (texOffsetOverride[i] == driDraw)
goto alreadyin;
if (firstEmpty == 16 && !texOffsetOverride[i])
@@ -360,37 +376,37 @@ __glXDRIbindTexImage(__GLXcontext *baseC
if (firstEmpty >= screen->lastTexOffsetOverride)
screen->lastTexOffsetOverride = firstEmpty + 1;
- texOffsetOverride[firstEmpty] = glxPixmap;
+ texOffsetOverride[firstEmpty] = driDraw;
alreadyin:
override = 1;
- glxPixmap->pDRICtx = &((__GLXDRIcontext*)baseContext)->driContext;
+ driDraw->ctx = (__GLXDRIcontext*)baseContext;
- if (texname == glxPixmap->texname)
+ if (texname == driDraw->texname)
return Success;
- glxPixmap->texname = texname;
+ driDraw->texname = texname;
- screen->texOffset->setTexOffset(glxPixmap->pDRICtx, texname, 0,
+ screen->texOffset->setTexOffset(&driDraw->ctx->driContext, texname, 0,
pixmap->drawable.depth,
pixmap->devKind);
}
nooverride:
- if (!glxPixmap->pDamage) {
+ if (!driDraw->pDamage) {
if (!override) {
- glxPixmap->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
- TRUE, pScreen, NULL);
- if (!glxPixmap->pDamage)
+ driDraw->pDamage = DamageCreate(NULL, NULL, DamageReportNone,
+ TRUE, pScreen, NULL);
+ if (!driDraw->pDamage)
return BadAlloc;
- DamageRegister ((DrawablePtr) pixmap, glxPixmap->pDamage);
+ DamageRegister ((DrawablePtr) pixmap, driDraw->pDamage);
}
pRegion = NULL;
} else {
- pRegion = DamageRegion(glxPixmap->pDamage);
+ pRegion = DamageRegion(driDraw->pDamage);
if (REGION_NIL(pRegion))
return Success;
}
@@ -469,7 +485,7 @@ nooverride:
}
if (!override)
- DamageEmpty(glxPixmap->pDamage);
+ DamageEmpty(driDraw->pDamage);
return Success;
}
@@ -477,19 +493,21 @@ nooverride:
static int
__glXDRIreleaseTexImage(__GLXcontext *baseContext,
int buffer,
- __GLXpixmap *pixmap)
+ __GLXdrawable *pixmap)
{
- ScreenPtr pScreen = pixmap->pScreen;
+ ScreenPtr pScreen = pixmap->pDraw->pScreen;
+ __GLXDRIdrawable *driDraw =
+ containerOf(pixmap, __GLXDRIdrawable, base);
__GLXDRIscreen * const screen =
(__GLXDRIscreen *) glxGetScreen(pScreen);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
- __GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
+ __GLXDRIdrawable **texOffsetOverride = screen->texOffsetOverride;
int i;
for (i = 0; i < lastOverride; i++) {
- if (texOffsetOverride[i] == pixmap) {
+ if (texOffsetOverride[i] == driDraw) {
if (screen->texOffsetFinish)
screen->texOffsetFinish((PixmapPtr)pixmap->pDraw);
@@ -696,9 +714,6 @@ filter_modes(__GLcontextModes **server_m
}
-#define containerOf(ptr, type, member) \
- (type *)( (char *)ptr - offsetof(type,member) )
-
static GLboolean
getDrawableInfo(__DRIdrawable *driDrawable,
unsigned int *index, unsigned int *stamp,
diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c
index b5de8c3..94ec5cc 100644
--- a/GL/glx/glxext.c
+++ b/GL/glx/glxext.c
@@ -45,7 +45,6 @@ __GLXcontext *__glXLastContext;
** X resources.
*/
RESTYPE __glXContextRes;
-RESTYPE __glXPixmapRes;
RESTYPE __glXDrawableRes;
RESTYPE __glXSwapBarrierRes;
@@ -102,32 +101,6 @@ static int ContextGone(__GLXcontext* cx,
}
/*
-** Free a GLX Pixmap.
-*/
-static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id)
-{
- PixmapPtr pPixmap = (PixmapPtr) pGlxPixmap->pDraw;
-
- pGlxPixmap->idExists = False;
- if (!pGlxPixmap->refcnt) {
-#ifdef XF86DRI
- if (pGlxPixmap->pDamage) {
- DamageUnregister (pGlxPixmap->pDraw, pGlxPixmap->pDamage);
- DamageDestroy(pGlxPixmap->pDamage);
- }
-#endif
- /*
- ** The DestroyPixmap routine should decrement the refcount and free
- ** only if it's zero.
- */
- (*pGlxPixmap->pScreen->DestroyPixmap)(pPixmap);
- xfree(pGlxPixmap);
- }
-
- return True;
-}
-
-/*
** Destroy routine that gets called when a drawable is freed. A drawable
** contains the ancillary buffers needed for rendering.
*/
@@ -136,24 +109,17 @@ static Bool DrawableGone(__GLXdrawable *
__GLXcontext *cx, *cx1;
/*
- ** Use glxPriv->type to figure out what kind of drawable this is. Don't
- ** use glxPriv->pDraw->type because by the time this routine is called,
- ** the pDraw might already have been freed.
+ ** When a drawable is destroyed, notify all context bound to
+ ** it, that there are no longer bound to anything.
*/
- if (glxPriv->type == DRAWABLE_WINDOW) {
- /*
- ** When a window is destroyed, notify all context bound to
- ** it, that there are no longer bound to anything.
- */
- for (cx = glxPriv->drawGlxc; cx; cx = cx1) {
- cx1 = cx->nextDrawPriv;
- cx->pendingState |= __GLX_PENDING_DESTROY;
- }
+ for (cx = glxPriv->drawGlxc; cx; cx = cx1) {
+ cx1 = cx->nextDrawPriv;
+ cx->pendingState |= __GLX_PENDING_DESTROY;
+ }
- for (cx = glxPriv->readGlxc; cx; cx = cx1) {
- cx1 = cx->nextReadPriv;
- cx->pendingState |= __GLX_PENDING_DESTROY;
- }
+ for (cx = glxPriv->readGlxc; cx; cx = cx1) {
+ cx1 = cx->nextReadPriv;
+ cx->pendingState |= __GLX_PENDING_DESTROY;
}
__glXUnrefDrawable(glxPriv);
@@ -319,7 +285,6 @@ void GlxExtensionInit(void)
__GLXprovider *p;
__glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
- __glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
__glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c
index 1f17292..df1cb2a 100644
--- a/GL/glx/glxutil.c
+++ b/GL/glx/glxutil.c
@@ -148,9 +148,5 @@ __glXDrawableInit(__GLXdrawable *drawabl
drawable->refCount = 1;
drawable->modes = modes;
- /* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */
- drawable->pGlxPixmap = (__GLXpixmap *)
- LookupIDByType(drawId, __glXPixmapRes);
-
return GL_TRUE;
}
diff-tree 2b0847c7aaf95b6b10f062dfff601032b2430a9b (from 600028305cc047e824b18369a026f89c9eb7e437)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Wed Aug 8 10:07:03 2007 -0400
Implement damage reporting for AIGLX.
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index 6389ad9..ae74311 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -784,6 +784,22 @@ getUST(int64_t *ust)
}
}
+static void __glXReportDamage(__DRIdrawable *driDraw,
+ int x, int y,
+ drm_clip_rect_t *rects, int num_rects,
+ GLboolean front_buffer)
+{
+ __GLXDRIdrawable *drawable =
+ containerOf(driDraw, __GLXDRIdrawable, driDrawable);
+ DrawablePtr pDraw = drawable->base.pDraw;
+ RegionRec region;
+
+ REGION_INIT(pDraw->pScreen, ®ion, (BoxPtr) rects, num_rects);
+ REGION_TRANSLATE(pScreen, ®ion, pDraw->x, pDraw->y);
+ DamageDamageRegion(pDraw, ®ion);
+ REGION_UNINIT(pDraw->pScreen, ®ion);
+}
+
/* Table of functions that we export to the driver. */
static const __DRIinterfaceMethods interface_methods = {
_gl_context_modes_create,
@@ -793,6 +809,8 @@ static const __DRIinterfaceMethods inter
getUST,
NULL, /* glXGetMscRateOML, */
+
+ __glXReportDamage,
};
static const char dri_driver_path[] = DRI_DRIVER_PATH;
diff-tree 600028305cc047e824b18369a026f89c9eb7e437 (from 781515bb637de4fd79e3c83817cb6ffa8f2d8a4f)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Thu May 31 22:55:47 2007 -0400
Move hyperpipe and swapbarrier extension funcs to screen private struct.
This gets rid of a couple more global arrays and gets the two extensions
more in line with the general extension mechanism.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index e09290e..732b135 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -2088,13 +2088,14 @@ int __glXDisp_BindSwapBarrierSGIX(__GLXc
int barrier = req->barrier;
DrawablePtr pDraw;
int screen, rc;
+ __GLXscreen *pGlxScreen;
rc = dixLookupDrawable(&pDraw, drawable, client, 0, DixUnknownAccess);
+ pGlxScreen = glxGetScreen(pDraw->pScreen);
if (rc == Success && (pDraw->type == DRAWABLE_WINDOW)) {
screen = pDraw->pScreen->myNum;
- if (__glXSwapBarrierFuncs &&
- __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc) {
- int ret = __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, barrier);
+ if (pGlxScreen->swapBarrierFuncs) {
+ int ret = pGlxScreen->swapBarrierFuncs->bindSwapBarrierFunc(screen, drawable, barrier);
if (ret == Success) {
if (barrier)
/* add source for cleanup when drawable is gone */
@@ -2118,10 +2119,11 @@ int __glXDisp_QueryMaxSwapBarriersSGIX(_
(xGLXQueryMaxSwapBarriersSGIXReq *) pc;
xGLXQueryMaxSwapBarriersSGIXReply reply;
int screen = req->screen;
+ __GLXscreen *pGlxScreen;
- if (__glXSwapBarrierFuncs &&
- __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc)
- reply.max = __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc(screen);
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+ if (pGlxScreen->swapBarrierFuncs)
+ reply.max = pGlxScreen->swapBarrierFuncs->queryMaxSwapBarriersFunc(screen);
else
reply.max = 0;
@@ -2154,11 +2156,12 @@ int __glXDisp_QueryHyperpipeNetworkSGIX(
int npipes=0;
int n= 0;
+ __GLXscreen *pGlxScreen;
- if (__glXHyperpipeFuncs &&
- __glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc != NULL) {
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+ if (pGlxScreen->hyperpipeFuncs) {
rdata =
- (__glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc(screen, &npipes, &n));
+ (pGlxScreen->hyperpipeFuncs->queryHyperpipeNetworkFunc(screen, &npipes, &n));
}
length = __GLX_PAD(n) >> 2;
reply.type = X_Reply;
@@ -2191,13 +2194,13 @@ int __glXDisp_DestroyHyperpipeConfigSGIX
int screen = req->screen;
int success = GLX_BAD_HYPERPIPE_SGIX;
int hpId ;
+ __GLXscreen *pGlxScreen;
hpId = req->hpId;
-
- if (__glXHyperpipeFuncs &&
- __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc != NULL) {
- success = __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc(screen, hpId);
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+ if (pGlxScreen->hyperpipeFuncs) {
+ success = pGlxScreen->hyperpipeFuncs->destroyHyperpipeConfigFunc(screen, hpId);
}
reply.type = X_Reply;
@@ -2229,12 +2232,13 @@ int __glXDisp_QueryHyperpipeConfigSGIX(_
int npipes=0;
int n= 0;
int hpId;
+ __GLXscreen *pGlxScreen;
hpId = req->hpId;
- if (__glXHyperpipeFuncs &&
- __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc != NULL) {
- rdata = __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc(screen, hpId,&npipes, &n);
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+ if (pGlxScreen->hyperpipeFuncs) {
+ rdata = pGlxScreen->hyperpipeFuncs->queryHyperpipeConfigFunc(screen, hpId,&npipes, &n);
}
length = __GLX_PAD(n) >> 2;
@@ -2272,14 +2276,15 @@ int __glXDisp_HyperpipeConfigSGIX(__GLXc
int npipes=0, networkId;
int hpId=-1;
+ __GLXscreen *pGlxScreen;
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
networkId = (int)req->networkId;
npipes = (int)req->npipes;
rdata = (void *)(req +1);
- if (__glXHyperpipeFuncs &&
- __glXHyperpipeFuncs[screen].hyperpipeConfigFunc != NULL) {
- __glXHyperpipeFuncs[screen].hyperpipeConfigFunc(screen,networkId,
+ if (pGlxScreen->hyperpipeFuncs) {
+ pGlxScreen->hyperpipeFuncs->hyperpipeConfigFunc(screen,networkId,
&hpId, &npipes,
(void *) rdata);
}
diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c
index ad02a89..b5de8c3 100644
--- a/GL/glx/glxext.c
+++ b/GL/glx/glxext.c
@@ -198,9 +198,10 @@ extern RESTYPE __glXSwapBarrierRes;
static int SwapBarrierGone(int screen, XID drawable)
{
- if (__glXSwapBarrierFuncs &&
- __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc != NULL) {
- __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc(screen, drawable, 0);
+ __GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+
+ if (pGlxScreen->swapBarrierFuncs) {
+ pGlxScreen->swapBarrierFuncs->bindSwapBarrierFunc(screen, drawable, 0);
}
FreeResourceByType(drawable, __glXSwapBarrierRes, FALSE);
return True;
diff --git a/GL/glx/glxext.h b/GL/glx/glxext.h
index 6774e4d..8de6434 100644
--- a/GL/glx/glxext.h
+++ b/GL/glx/glxext.h
@@ -106,25 +106,5 @@ extern int GlxInitVisuals(
int preferredVis
);
-typedef struct {
- void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
- void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
- int (* destroyHyperpipeConfigFunc)(int, int);
- void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
-} __GLXHyperpipeExtensionFuncs;
-
-extern void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
-
-extern __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs;
-
-typedef struct {
- int (* bindSwapBarrierFunc)(int, XID, int);
- int (* queryMaxSwapBarriersFunc)(int);
-} __GLXSwapBarrierExtensionFuncs;
-
-extern void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
-
-extern __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs;
-
#endif /* _glxext_h_ */
diff --git a/GL/glx/glxscreens.c b/GL/glx/glxscreens.c
index 75cb871..c6f060b 100644
--- a/GL/glx/glxscreens.c
+++ b/GL/glx/glxscreens.c
@@ -181,12 +181,6 @@ static char GLXServerExtensions[] =
"GLX_MESA_copy_sub_buffer "
;
-__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
-static int __glXNumSwapBarrierFuncs = 0;
-__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
-static int __glXNumHyperpipeFuncs = 0;
-
-
/*
** This hook gets called when a window moves or changes size.
*/
@@ -256,34 +250,16 @@ static Bool glxPositionWindow(WindowPtr
void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs)
{
- if (__glXNumHyperpipeFuncs < screen + 1) {
- __glXHyperpipeFuncs = xrealloc(__glXHyperpipeFuncs,
- (screen+1) * sizeof(__GLXHyperpipeExtensionFuncs));
- __glXNumHyperpipeFuncs = screen + 1;
- }
+ __GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
- __glXHyperpipeFuncs[screen].queryHyperpipeNetworkFunc =
- *funcs->queryHyperpipeNetworkFunc;
- __glXHyperpipeFuncs[screen].queryHyperpipeConfigFunc =
- *funcs->queryHyperpipeConfigFunc;
- __glXHyperpipeFuncs[screen].destroyHyperpipeConfigFunc =
- *funcs->destroyHyperpipeConfigFunc;
- __glXHyperpipeFuncs[screen].hyperpipeConfigFunc =
- *funcs->hyperpipeConfigFunc;
+ pGlxScreen->hyperpipeFuncs = funcs;
}
void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs)
{
- if (__glXNumSwapBarrierFuncs < screen + 1) {
- __glXSwapBarrierFuncs = xrealloc(__glXSwapBarrierFuncs,
- (screen+1) * sizeof(__GLXSwapBarrierExtensionFuncs));
- __glXNumSwapBarrierFuncs = screen + 1;
- }
+ __GLXscreen *pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
- __glXSwapBarrierFuncs[screen].bindSwapBarrierFunc =
- funcs->bindSwapBarrierFunc;
- __glXSwapBarrierFuncs[screen].queryMaxSwapBarriersFunc =
- funcs->queryMaxSwapBarriersFunc;
+ pGlxScreen->swapBarrierFuncs = funcs;
}
static Bool
diff --git a/GL/glx/glxscreens.h b/GL/glx/glxscreens.h
index d92a795..d887beb 100644
--- a/GL/glx/glxscreens.h
+++ b/GL/glx/glxscreens.h
@@ -42,6 +42,21 @@
#include "GL/internal/glcore.h"
+typedef struct {
+ void * (* queryHyperpipeNetworkFunc)(int, int *, int *);
+ void * (* queryHyperpipeConfigFunc)(int, int, int *, int *);
+ int (* destroyHyperpipeConfigFunc)(int, int);
+ void * (* hyperpipeConfigFunc)(int, int, int *, int *, void *);
+} __GLXHyperpipeExtensionFuncs;
+
+typedef struct {
+ int (* bindSwapBarrierFunc)(int, XID, int);
+ int (* queryMaxSwapBarriersFunc)(int);
+} __GLXSwapBarrierExtensionFuncs;
+
+void __glXHyperpipeInit(int screen, __GLXHyperpipeExtensionFuncs *funcs);
+void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs);
+
/*
** Screen dependent data. These methods are the interface between the DIX
** and DDX layers of the GLX server extension. The methods provide an
@@ -62,6 +77,9 @@ struct __GLXscreen {
int (*swapInterval) (__GLXdrawable *drawable,
int interval);
+ __GLXHyperpipeExtensionFuncs *hyperpipeFuncs;
+ __GLXSwapBarrierExtensionFuncs *swapBarrierFuncs;
+
ScreenPtr pScreen;
/**
diff-tree 781515bb637de4fd79e3c83817cb6ffa8f2d8a4f (from 72a3d68a2f5abcd09fef1a55e976e1a5731d4b02)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Wed May 30 23:25:03 2007 -0400
Convert GLX module to use screen private indexes like everything else.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index 597c7bd..e09290e 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -131,8 +131,8 @@ int DoCreateContext(__GLXclientState *cl
return BadValue;
}
pScreen = screenInfo.screens[screen];
- pGlxScreen = __glXActiveScreens[screen];
-
+ pGlxScreen = glxGetScreen(pScreen);
+
/*
** Check if the visual ID is valid for this screen.
*/
@@ -149,7 +149,7 @@ int DoCreateContext(__GLXclientState *cl
/*
** Get configuration of the visual. This assumes that the
- ** glXActiveScreens structure contains visual configurations only for the
+ ** glxScreen structure contains visual configurations only for the
** subset of Visuals that are supported by this implementation of the
** OpenGL.
*/
@@ -931,7 +931,7 @@ int DoGetVisualConfigs(__GLXclientState
client->errorValue = screen;
return BadValue;
}
- pGlxScreen = __glXActiveScreens[screen];
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
reply.numVisuals = pGlxScreen->numUsableVisuals;
reply.numProps = __GLX_TOTAL_CONFIG;
@@ -1119,7 +1119,7 @@ int DoGetFBConfigs(__GLXclientState *cl,
client->errorValue = screen;
return BadValue;
}
- pGlxScreen = __glXActiveScreens[screen];
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
/* Create the "extra" 32bpp ARGB visual, if not already added.
* XXX This is questionable place to do so! Re-examine this someday.
@@ -1245,7 +1245,7 @@ static int ValidateCreateDrawable(Client
}
/* Get configuration of the visual. */
- pGlxScreen = __glXgetActiveScreen(screenNum);
+ pGlxScreen = glxGetScreen(pScreen);
*modes = _gl_context_modes_find_visual(pGlxScreen->modes, fbconfigId);
if (*modes == NULL) {
/* Visual not support on this screen by this OpenGL implementation. */
@@ -1286,7 +1286,7 @@ int DoCreateGLXPixmap(__GLXclientState *
return BadAlloc;
}
pGlxPixmap->pDraw = pDraw;
- pGlxPixmap->pGlxScreen = __glXgetActiveScreen(screenNum);
+ pGlxPixmap->pGlxScreen = glxGetScreen(pDraw->pScreen);
pGlxPixmap->pScreen = pDraw->pScreen;
pGlxPixmap->idExists = True;
#ifdef XF86DRI
@@ -1430,7 +1430,7 @@ int __glXDisp_CreateWindow(__GLXclientSt
/* FIXME: We need to check that the window visual is compatible
* with the specified fbconfig. */
- screen = __glXgetActiveScreen(req->screen);
+ screen = glxGetScreen(screenInfo.screens[req->screen]);
glxPriv = screen->createDrawable(screen, pDraw, req->glxwindow, modes);
if (glxPriv == NULL)
return BadAlloc;
@@ -2368,7 +2368,7 @@ int __glXDisp_QueryExtensionsString(__GL
return BadValue;
}
- ptr = __glXActiveScreens[screen]->GLXextensions;
+ ptr = glxGetScreen(screenInfo.screens[screen])->GLXextensions;
n = strlen(ptr) + 1;
length = __GLX_PAD(n) >> 2;
@@ -2404,6 +2404,7 @@ int __glXDisp_QueryServerString(__GLXcli
size_t n, length;
const char *ptr;
char *buf;
+ __GLXscreen *pGlxScreen;
name = req->name;
screen = req->screen;
@@ -2414,15 +2415,17 @@ int __glXDisp_QueryServerString(__GLXcli
client->errorValue = screen;
return BadValue;
}
+ pGlxScreen = glxGetScreen(screenInfo.screens[screen]);
+
switch(name) {
case GLX_VENDOR:
- ptr = __glXActiveScreens[screen]->GLXvendor;
+ ptr = pGlxScreen->GLXvendor;
break;
case GLX_VERSION:
- ptr = __glXActiveScreens[screen]->GLXversion;
+ ptr = pGlxScreen->GLXversion;
break;
case GLX_EXTENSIONS:
- ptr = __glXActiveScreens[screen]->GLXextensions;
+ ptr = pGlxScreen->GLXextensions;
break;
default:
return BadValue;
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index 116689f..6389ad9 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -103,7 +103,7 @@ __glXDRIleaveServer(GLboolean rendering)
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
__GLXDRIscreen * const screen =
- (__GLXDRIscreen *) __glXgetActiveScreen(i);
+ (__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
@@ -125,7 +125,7 @@ __glXDRIleaveServer(GLboolean rendering)
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
__GLXDRIscreen * const screen =
- (__GLXDRIscreen *) __glXgetActiveScreen(i);
+ (__GLXDRIscreen *) glxGetScreen(screenInfo.screens[i]);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
@@ -153,8 +153,8 @@ __glXDRIenterServer(GLboolean rendering)
int i;
for (i = 0; rendering && i < screenInfo.numScreens; i++) {
- __GLXDRIscreen * const screen =
- (__GLXDRIscreen *) __glXgetActiveScreen(i);
+ __GLXDRIscreen * const screen = (__GLXDRIscreen *)
+ glxGetScreen(screenInfo.screens[i]);
if (screen->lastTexOffsetOverride) {
CALL_Flush(GET_DISPATCH(), ());
@@ -205,7 +205,7 @@ __glXDRIdrawableSwapInterval(__GLXdrawab
{
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
__GLXDRIscreen *screen = (__GLXDRIscreen *)
- __glXgetActiveScreen(baseDrawable->pDraw->pScreen->myNum);
+ glxGetScreen(baseDrawable->pDraw->pScreen);
if (screen->swapControl)
screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
@@ -220,7 +220,7 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawa
{
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
__GLXDRIscreen *screen = (__GLXDRIscreen *)
- __glXgetActiveScreen(basePrivate->pDraw->pScreen->myNum);
+ glxGetScreen(basePrivate->pDraw->pScreen);
if (screen->copySubBuffer)
screen->copySubBuffer->copySubBuffer(&private->driDrawable,
@@ -328,8 +328,7 @@ __glXDRIbindTexImage(__GLXcontext *baseC
int bpp, override = 0, texname;
GLenum format, type;
ScreenPtr pScreen = glxPixmap->pScreen;
- __GLXDRIscreen * const screen =
- (__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
+ __GLXDRIscreen * const screen = (__GLXDRIscreen *) glxGetScreen(pScreen);
CALL_GetIntegerv(GET_DISPATCH(), (glxPixmap->target == GL_TEXTURE_2D ?
GL_TEXTURE_BINDING_2D :
@@ -482,7 +481,7 @@ __glXDRIreleaseTexImage(__GLXcontext *ba
{
ScreenPtr pScreen = pixmap->pScreen;
__GLXDRIscreen * const screen =
- (__GLXDRIscreen *) __glXgetActiveScreen(pScreen->myNum);
+ (__GLXDRIscreen *) glxGetScreen(pScreen);
GLuint lastOverride = screen->lastTexOffsetOverride;
if (lastOverride) {
@@ -801,7 +800,8 @@ static const char dri_driver_path[] = DR
static Bool
glxDRIEnterVT (int index, int flags)
{
- __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
+ __GLXDRIscreen *screen = (__GLXDRIscreen *)
+ glxGetScreen(screenInfo.screens[index]);
LogMessage(X_INFO, "AIGLX: Resuming AIGLX clients after VT switch\n");
@@ -816,7 +816,8 @@ glxDRIEnterVT (int index, int flags)
static void
glxDRILeaveVT (int index, int flags)
{
- __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(index);
+ __GLXDRIscreen *screen = (__GLXDRIscreen *)
+ glxGetScreen(screenInfo.screens[index]);
LogMessage(X_INFO, "AIGLX: Suspending AIGLX clients for VT switch\n");
diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c
index 5b621d3..ad02a89 100644
--- a/GL/glx/glxext.c
+++ b/GL/glx/glxext.c
@@ -45,7 +45,6 @@ __GLXcontext *__glXLastContext;
** X resources.
*/
RESTYPE __glXContextRes;
-RESTYPE __glXClientRes;
RESTYPE __glXPixmapRes;
RESTYPE __glXDrawableRes;
RESTYPE __glXSwapBarrierRes;
@@ -55,11 +54,7 @@ RESTYPE __glXSwapBarrierRes;
*/
xGLXSingleReply __glXReply;
-/*
-** A set of state for each client. The 0th one is unused because client
-** indices start at 1, not 0.
-*/
-static __GLXclientState *__glXClients[MAXCLIENTS + 1];
+static int glxClientPrivateIndex;
/*
** Client that called into GLX dispatch.
@@ -77,29 +72,6 @@ static int __glXDispatch(ClientPtr);
static void ResetExtension(ExtensionEntry* extEntry)
{
__glXFlushContextCache();
- __glXResetScreens();
-}
-
-/*
-** Initialize the per-client context storage.
-*/
-static void ResetClientState(int clientIndex)
-{
- __GLXclientState *cl = __glXClients[clientIndex];
-
- if (cl->returnBuf) xfree(cl->returnBuf);
- if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
- if (cl->currentContexts) xfree(cl->currentContexts);
- memset(cl, 0, sizeof(__GLXclientState));
- /*
- ** By default, assume that the client supports
- ** GLX major version 1 minor version 0 protocol.
- */
- cl->GLClientmajorVersion = 1;
- cl->GLClientminorVersion = 0;
- if (cl->GLClientextensions)
- xfree(cl->GLClientextensions);
-
}
/*
@@ -130,39 +102,6 @@ static int ContextGone(__GLXcontext* cx,
}
/*
-** Free a client's state.
-*/
-static int ClientGone(int clientIndex, XID id)
-{
- __GLXcontext *cx;
- __GLXclientState *cl = __glXClients[clientIndex];
- int i;
-
- if (cl) {
- /*
- ** Free all the contexts that are current for this client.
- */
- for (i=0; i < cl->numCurrentContexts; i++) {
- cx = cl->currentContexts[i];
- if (cx) {
- cx->isCurrent = GL_FALSE;
- if (!cx->idExists) {
- __glXFreeContext(cx);
- }
- }
- }
- /*
- ** Re-initialize the client state structure. Don't free it because
- ** we'll probably get another client with this index and use the struct
- ** again. There is a maximum of MAXCLIENTS of these structures.
- */
- ResetClientState(clientIndex);
- }
-
- return True;
-}
-
-/*
** Free a GLX Pixmap.
*/
static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id)
@@ -309,22 +248,87 @@ int __glXError(int error)
return __glXErrorBase + error;
}
+__GLXclientState *
+glxGetClient(ClientPtr pClient)
+{
+ return (__GLXclientState *) pClient->devPrivates[glxClientPrivateIndex].ptr;
+}
+
+static void
+glxClientCallback (CallbackListPtr *list,
+ pointer closure,
+ pointer data)
+{
+ NewClientInfoRec *clientinfo = (NewClientInfoRec *) data;
+ ClientPtr pClient = clientinfo->client;
+ __GLXclientState *cl = glxGetClient(pClient);
+ __GLXcontext *cx;
+ int i;
+
+ switch (pClient->clientState) {
+ case ClientStateRunning:
+ /*
+ ** By default, assume that the client supports
+ ** GLX major version 1 minor version 0 protocol.
+ */
+ cl->GLClientmajorVersion = 1;
+ cl->GLClientminorVersion = 0;
+ cl->client = pClient;
+ break;
+
+ case ClientStateGone:
+ for (i = 0; i < cl->numCurrentContexts; i++) {
+ cx = cl->currentContexts[i];
+ if (cx) {
+ cx->isCurrent = GL_FALSE;
+ if (!cx->idExists)
+ __glXFreeContext(cx);
+ }
+ }
+
+ if (cl->returnBuf) xfree(cl->returnBuf);
+ if (cl->largeCmdBuf) xfree(cl->largeCmdBuf);
+ if (cl->currentContexts) xfree(cl->currentContexts);
+ if (cl->GLClientextensions) xfree(cl->GLClientextensions);
+ break;
+
+ default:
+ break;
+ }
+}
+
/************************************************************************/
+static __GLXprovider *__glXProviderStack;
+
+void GlxPushProvider(__GLXprovider *provider)
+{
+ provider->next = __glXProviderStack;
+ __glXProviderStack = provider;
+}
+
/*
** Initialize the GLX extension.
*/
void GlxExtensionInit(void)
{
ExtensionEntry *extEntry;
+ ScreenPtr pScreen;
int i;
+ __GLXprovider *p;
__glXContextRes = CreateNewResourceType((DeleteType)ContextGone);
- __glXClientRes = CreateNewResourceType((DeleteType)ClientGone);
__glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone);
__glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone);
__glXSwapBarrierRes = CreateNewResourceType((DeleteType)SwapBarrierGone);
+ glxClientPrivateIndex = AllocateClientPrivateIndex ();
+ if (!AllocateClientPrivate (glxClientPrivateIndex,
+ sizeof (__GLXclientState)))
+ return;
+ if (!AddCallback (&ClientStateCallback, glxClientCallback, 0))
+ return;
+
/*
** Add extension to server extensions.
*/
@@ -343,17 +347,17 @@ void GlxExtensionInit(void)
__glXErrorBase = extEntry->errorBase;
- /*
- ** Initialize table of client state. There is never a client 0.
- */
- for (i = 1; i <= MAXCLIENTS; i++) {
- __glXClients[i] = 0;
- }
+ for (i = 0; i < screenInfo.numScreens; i++) {
+ pScreen = screenInfo.screens[i];
- /*
- ** Initialize screen specific data.
- */
- __glXInitScreens();
+ for (p = __glXProviderStack; p != NULL; p = p->next) {
+ if (p->screenProbe(pScreen) != NULL)
+ LogMessage(X_INFO,
+ "GLX: Initialized %s GL provider for screen %d\n",
+ p->name, i);
+ break;
+ }
+ }
}
/************************************************************************/
@@ -421,11 +425,9 @@ void glxSuspendClients(void)
{
int i;
- for (i = 1; i <= MAXCLIENTS; i++) {
- if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
- continue;
-
- IgnoreClient(__glXClients[i]->client);
+ for (i = 1; i < currentMaxClients; i++) {
+ if (glxGetClient(clients[i])->inUse)
+ IgnoreClient(clients[i]);
}
glxBlockClients = TRUE;
@@ -438,11 +440,9 @@ void glxResumeClients(void)
glxBlockClients = FALSE;
- for (i = 1; i <= MAXCLIENTS; i++) {
- if (__glXClients[i] == NULL || !__glXClients[i]->inUse)
- continue;
-
- AttendClient(__glXClients[i]->client);
+ for (i = 1; i < currentMaxClients; i++) {
+ if (glxGetClient(clients[i])->inUse)
+ AttendClient(clients[i]);
}
__glXleaveServer(GL_FALSE);
@@ -504,29 +504,9 @@ static int __glXDispatch(ClientPtr clien
int retval;
opcode = stuff->glxCode;
- cl = __glXClients[client->index];
- if (!cl) {
- cl = (__GLXclientState *) xalloc(sizeof(__GLXclientState));
- __glXClients[client->index] = cl;
- if (!cl) {
- return BadAlloc;
- }
- memset(cl, 0, sizeof(__GLXclientState));
- }
-
- if (!cl->inUse) {
- /*
- ** This is first request from this client. Associate a resource
- ** with the client so we will be notified when the client dies.
- */
- XID xid = FakeClientID(client->index);
- if (!AddResource( xid, __glXClientRes, (pointer)(long)client->index)) {
- return BadAlloc;
- }
- ResetClientState(client->index);
- cl->inUse = GL_TRUE;
- cl->client = client;
- }
+ cl = glxGetClient(client);
+ /* Mark it in use so we suspend it on VT switch. */
+ cl->inUse = TRUE;
/*
** If we're expecting a glXRenderLarge request, this better be one.
diff --git a/GL/glx/glxscreens.c b/GL/glx/glxscreens.c
index 43447a4..75cb871 100644
--- a/GL/glx/glxscreens.c
+++ b/GL/glx/glxscreens.c
@@ -45,6 +45,8 @@
#include "glxutil.h"
#include "glxext.h"
+static int glxScreenPrivateIndex;
+
const char GLServerVersion[] = "1.4";
static const char GLServerExtensions[] =
"GL_ARB_depth_texture "
@@ -179,36 +181,31 @@ static char GLXServerExtensions[] =
"GLX_MESA_copy_sub_buffer "
;
-__GLXscreen **__glXActiveScreens;
-
__GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL;
static int __glXNumSwapBarrierFuncs = 0;
__GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL;
static int __glXNumHyperpipeFuncs = 0;
-__GLXscreen *__glXgetActiveScreen(int num) {
- return __glXActiveScreens[num];
-}
-
/*
** This hook gets called when a window moves or changes size.
*/
-static Bool PositionWindow(WindowPtr pWin, int x, int y)
+static Bool glxPositionWindow(WindowPtr pWin, int x, int y)
{
ScreenPtr pScreen;
__GLXcontext *glxc;
__GLXdrawable *glxPriv;
Bool ret;
+ __GLXscreen *pGlxScreen;
/*
** Call wrapped position window routine
*/
pScreen = pWin->drawable.pScreen;
- pScreen->PositionWindow =
- __glXActiveScreens[pScreen->myNum]->WrappedPositionWindow;
+ pGlxScreen = glxGetScreen(pScreen);
+ pScreen->PositionWindow = pGlxScreen->PositionWindow;
ret = (*pScreen->PositionWindow)(pWin, x, y);
- pScreen->PositionWindow = PositionWindow;
+ pScreen->PositionWindow = glxPositionWindow;
/*
** Tell all contexts rendering into this window that the window size
@@ -289,80 +286,59 @@ void __glXSwapBarrierInit(int screen, __
funcs->queryMaxSwapBarriersFunc;
}
-static __GLXprovider *__glXProviderStack;
-
-void GlxPushProvider(__GLXprovider *provider)
+static Bool
+glxCloseScreen (int index, ScreenPtr pScreen)
{
- provider->next = __glXProviderStack;
- __glXProviderStack = provider;
-}
+ __GLXscreen *pGlxScreen = glxGetScreen(pScreen);
-void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen)
-{
- screen->pScreen = pScreen;
- screen->GLextensions = xstrdup(GLServerExtensions);
- screen->GLXvendor = xstrdup(GLXServerVendorName);
- screen->GLXversion = xstrdup(GLXServerVersion);
- screen->GLXextensions = xstrdup(GLXServerExtensions);
+ pScreen->CloseScreen = pGlxScreen->CloseScreen;
+ pScreen->PositionWindow = pGlxScreen->PositionWindow;
- screen->WrappedPositionWindow = pScreen->PositionWindow;
- pScreen->PositionWindow = PositionWindow;
+ pGlxScreen->destroy(pGlxScreen);
- __glXScreenInitVisuals(screen);
+ return pScreen->CloseScreen(index, pScreen);
}
-void
-__glXScreenDestroy(__GLXscreen *screen)
+__GLXscreen *
+glxGetScreen(ScreenPtr pScreen)
{
- xfree(screen->GLXvendor);
- xfree(screen->GLXversion);
- xfree(screen->GLXextensions);
- xfree(screen->GLextensions);
+ return (__GLXscreen *) pScreen->devPrivates[glxScreenPrivateIndex].ptr;
}
-void __glXInitScreens(void)
+void __glXScreenInit(__GLXscreen *glxScreen, ScreenPtr pScreen)
{
- GLint i;
- ScreenPtr pScreen;
- __GLXprovider *p;
- size_t size;
+ static int glxGeneration;
- /*
- ** This alloc has to work or else the server might as well core dump.
- */
- size = screenInfo.numScreens * sizeof(__GLXscreen *);
- __glXActiveScreens = xalloc(size);
- memset(__glXActiveScreens, 0, size);
-
- for (i = 0; i < screenInfo.numScreens; i++) {
- pScreen = screenInfo.screens[i];
-
- for (p = __glXProviderStack; p != NULL; p = p->next) {
- __glXActiveScreens[i] = p->screenProbe(pScreen);
- if (__glXActiveScreens[i] != NULL) {
- LogMessage(X_INFO,
- "GLX: Initialized %s GL provider for screen %d\n",
- p->name, i);
- break;
- }
- }
+ if (glxGeneration != serverGeneration)
+ {
+ glxScreenPrivateIndex = AllocateScreenPrivateIndex ();
+ if (glxScreenPrivateIndex == -1)
+ return;
+
+ glxGeneration = serverGeneration;
}
-}
-void __glXResetScreens(void)
-{
- int i;
+ glxScreen->pScreen = pScreen;
+ glxScreen->GLextensions = xstrdup(GLServerExtensions);
+ glxScreen->GLXvendor = xstrdup(GLXServerVendorName);
+ glxScreen->GLXversion = xstrdup(GLXServerVersion);
+ glxScreen->GLXextensions = xstrdup(GLXServerExtensions);
+
+ glxScreen->PositionWindow = pScreen->PositionWindow;
+ pScreen->PositionWindow = glxPositionWindow;
+
+ glxScreen->CloseScreen = pScreen->CloseScreen;
+ pScreen->CloseScreen = glxCloseScreen;
+
+ __glXScreenInitVisuals(glxScreen);
- for (i = 0; i < screenInfo.numScreens; i++)
- if (__glXActiveScreens[i])
- __glXActiveScreens[i]->destroy(__glXActiveScreens[i]);
-
- xfree(__glXActiveScreens);
- xfree(__glXHyperpipeFuncs);
- xfree(__glXSwapBarrierFuncs);
- __glXNumHyperpipeFuncs = 0;
- __glXNumSwapBarrierFuncs = 0;
- __glXHyperpipeFuncs = NULL;
- __glXSwapBarrierFuncs = NULL;
- __glXActiveScreens = NULL;
+ pScreen->devPrivates[glxScreenPrivateIndex].ptr = (pointer) glxScreen;
+}
+
+void __glXScreenDestroy(__GLXscreen *screen)
+{
+ xfree(screen->GLXvendor);
+ xfree(screen->GLXversion);
+ xfree(screen->GLXextensions);
+ xfree(screen->GLextensions);
}
diff --git a/GL/glx/glxscreens.h b/GL/glx/glxscreens.h
index bba4557..d92a795 100644
--- a/GL/glx/glxscreens.h
+++ b/GL/glx/glxscreens.h
@@ -79,18 +79,12 @@ struct __GLXscreen {
char *GLXversion;
char *GLXextensions;
- /*
- ** Things that are not statically set.
- */
- Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y);
-
+ Bool (*PositionWindow)(WindowPtr pWin, int x, int y);
+ Bool (*CloseScreen)(int index, ScreenPtr pScreen);
};
void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen);
void __glXScreenDestroy(__GLXscreen *screen);
-void __glXInitScreens(void);
-extern void __glXResetScreens(void);
-
#endif /* !__GLX_screens_h__ */
diff --git a/GL/glx/glxserver.h b/GL/glx/glxserver.h
index b6b5592..45de8e7 100644
--- a/GL/glx/glxserver.h
+++ b/GL/glx/glxserver.h
@@ -90,9 +90,8 @@ typedef XID GLXDrawable;
typedef struct __GLXclientStateRec __GLXclientState;
-extern __GLXscreen **__glXActiveScreens;
-extern GLint __glXNumActiveScreens;
-extern __GLXscreen *__glXgetActiveScreen(int num);
+extern __GLXscreen *glxGetScreen(ScreenPtr pScreen);
+extern __GLXclientState *glxGetClient(ClientPtr pClient);
/************************************************************************/
diff --git a/hw/xfree86/dri/dri.c b/hw/xfree86/dri/dri.c
index d1bbfcd..1a54f2c 100644
--- a/hw/xfree86/dri/dri.c
+++ b/hw/xfree86/dri/dri.c
@@ -972,7 +972,7 @@ static Bool
DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv)
{
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
- __GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
+ __GLXscreen *pGLXScreen = glxGetScreen(pScreen);
__GLcontextModes *modes = pGLXScreen->modes;
void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
DRIContextPrivPtr pDRIContextPriv;
@@ -1036,7 +1036,7 @@ DRICreateContext(ScreenPtr pScreen, Visu
XID context, drm_context_t * pHWContext)
{
DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
- __GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum);
+ __GLXscreen *pGLXScreen = glxGetScreen(pScreen);
__GLcontextModes *modes = pGLXScreen->modes;
void **pVisualConfigPriv = pGLXScreen->pVisualPriv;
DRIContextPrivPtr pDRIContextPriv;
diff-tree 72a3d68a2f5abcd09fef1a55e976e1a5731d4b02 (from 45cc03726b49f6ad4afe6c3fb4ad65d1051928b4)
Author: Kristian Høgsberg <krh at redhat.com>
Date: Thu May 10 11:16:50 2007 -0400
Update the AIGLX DRI loader to use the new DRI interface.
This lets us drop a bunch of workarounds and use the new DRI extension
mechanism.
diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c
index 900a347..597c7bd 100644
--- a/GL/glx/glxcmds.c
+++ b/GL/glx/glxcmds.c
@@ -73,6 +73,8 @@ GlxSetRenderTables (struct _glapi_table
void
__glXContextDestroy(__GLXcontext *context)
{
+ if (!context->isDirect)
+ __glXDeassociateContext(context);
__glXFlushContextCache();
}
diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c
index c1f3eb7..116689f 100644
--- a/GL/glx/glxdri.c
+++ b/GL/glx/glxdri.c
@@ -59,22 +59,21 @@
#include "dispatch.h"
#include "extension_string.h"
-
-#define STRINGIFY(macro_or_string) STRINGIFY_ARG (macro_or_string)
-#define STRINGIFY_ARG(contents) #contents
-
-typedef struct __GLXDRIscreen __GLXDRIscreen;
-typedef struct __GLXDRIcontext __GLXDRIcontext;
+typedef struct __GLXDRIscreen __GLXDRIscreen;
+typedef struct __GLXDRIcontext __GLXDRIcontext;
typedef struct __GLXDRIdrawable __GLXDRIdrawable;
struct __GLXDRIscreen {
__GLXscreen base;
+ __DRIscreen driScreen;
+ void *driver;
- __DRIscreen driScreen;
- void *driver;
+ xf86EnterVTProc *enterVT;
+ xf86LeaveVTProc *leaveVT;
- xf86EnterVTProc *enterVT;
- xf86LeaveVTProc *leaveVT;
+ __DRIcopySubBufferExtension *copySubBuffer;
+ __DRIswapControlExtension *swapControl;
+ __DRItexOffsetExtension *texOffset;
DRITexOffsetStartProcPtr texOffsetStart;
DRITexOffsetFinishProcPtr texOffsetFinish;
@@ -85,51 +84,17 @@ struct __GLXDRIscreen {
};
struct __GLXDRIcontext {
- __GLXcontext base;
-
- __DRIcontext driContext;
+ __GLXcontext base;
+ __DRIcontext driContext;
+ XID hwContextID;
};
struct __GLXDRIdrawable {
- __GLXdrawable base;
-
- __DRIdrawable *driDrawable;
+ __GLXdrawable base;
+ __DRIdrawable driDrawable;
};
-/* History:
- * 20021121 - Initial version
- * 20021128 - Added __glXWindowExists() function
- * 20021207 - Added support for dynamic GLX extensions,
- * GLX_SGI_swap_control, GLX_SGI_video_sync,
- * GLX_OML_sync_control, and GLX_MESA_swap_control.
- * Never officially released. Do NOT test against
- * this version. Use 20030317 instead.
- * 20030317 - Added support GLX_SGIX_fbconfig,
- * GLX_MESA_swap_frame_usage, GLX_OML_swap_method,
- * GLX_{ARB,SGIS}_multisample, and
- * GLX_SGIX_visual_select_group.
- * 20030606 - Added support for GLX_SGI_make_current_read.
- * 20030813 - Made support for dynamic extensions multi-head aware.
- * 20030818 - Added support for GLX_MESA_allocate_memory in place of the
- * deprecated GLX_NV_vertex_array_range & GLX_MESA_agp_offset
- * interfaces.
- * 20031201 - Added support for the first round of DRI interface changes.
- * Do NOT test against this version! It has binary
- * compatibility bugs, use 20040317 instead.
- * 20040317 - Added the 'mode' field to __DRIcontextRec.
- * 20040415 - Added support for bindContext3 and unbindContext3.
- * 20040602 - Add __glXGetDrawableInfo. I though that was there
- * months ago. :(
- * 20050727 - Gut all the old interfaces. This breaks compatability with
- * any DRI driver built to any previous version.
- * 20060314 - Added support for GLX_MESA_copy_sub_buffer.
- */
-
-#define INTERNAL_VERSION 20050727
-
-static const char CREATE_NEW_SCREEN_FUNC[] =
- "__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION);
-
+static const char CREATE_NEW_SCREEN_FUNC[] = __DRI_CREATE_NEW_SCREEN_STRING;
static void
__glXDRIleaveServer(GLboolean rendering)
@@ -171,12 +136,11 @@ __glXDRIleaveServer(GLboolean rendering)
__GLXpixmap *pGlxPix = texOffsetOverride[j];
if (pGlxPix && pGlxPix->texname) {
- screen->driScreen.setTexOffset(pGlxPix->pDRICtx,
- pGlxPix->texname,
- pGlxPix->offset,
- pGlxPix->pDraw->depth,
- ((PixmapPtr)pGlxPix->pDraw)->
- devKind);
+ screen->texOffset->setTexOffset(pGlxPix->pDRICtx,
+ pGlxPix->texname,
+ pGlxPix->offset,
+ pGlxPix->pDraw->depth,
+ ((PixmapPtr)pGlxPix->pDraw)->devKind);
}
}
}
@@ -201,29 +165,17 @@ __glXDRIenterServer(GLboolean rendering)
DRIWakeupHandler(NULL, 0, NULL);
}
-/**
- * \bug
- * We're jumping through hoops here to get the DRIdrawable which the DRI
- * driver tries to keep to it self... cf. FIXME in \c createDrawable.
- */
static void
-__glXDRIdrawableFoo(__GLXDRIdrawable *draw)
+__glXDRIdrawableDestroy(__GLXdrawable *drawable)
{
- __GLXDRIscreen * const screen =
- (__GLXDRIscreen *) __glXgetActiveScreen(draw->base.pDraw->pScreen->myNum);
+ __GLXDRIdrawable *private = (__GLXDRIdrawable *) drawable;
- draw->driDrawable = (*screen->driScreen.getDrawable)(NULL,
- draw->base.drawId,
- screen->driScreen.private);
-}
+ (*private->driDrawable.destroyDrawable)(&private->driDrawable);
-static void
-__glXDRIdrawableDestroy(__GLXdrawable *private)
-{
-#if 0
- (*glxPriv->driDrawable.destroyDrawable)(NULL,
- glxPriv->driDrawable.private);
-#endif
+ __glXenterServer(GL_FALSE);
+ DRIDestroyDrawable(drawable->pDraw->pScreen,
+ serverClient, drawable->pDraw);
+ __glXleaveServer(GL_FALSE);
xfree(private);
}
@@ -242,10 +194,7 @@ __glXDRIdrawableSwapBuffers(__GLXdrawabl
{
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
- __glXDRIdrawableFoo(private);
-
- (*private->driDrawable->swapBuffers)(NULL,
- private->driDrawable->private);
+ (*private->driDrawable.swapBuffers)(&private->driDrawable);
return TRUE;
}
@@ -255,10 +204,12 @@ static int
__glXDRIdrawableSwapInterval(__GLXdrawable *baseDrawable, int interval)
{
__GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseDrawable;
+ __GLXDRIscreen *screen = (__GLXDRIscreen *)
+ __glXgetActiveScreen(baseDrawable->pDraw->pScreen->myNum);
- __glXDRIdrawableFoo(draw);
+ if (screen->swapControl)
+ screen->swapControl->setSwapInterval(&draw->driDrawable, interval);
- draw->driDrawable->swap_interval = interval;
return 0;
}
@@ -268,22 +219,26 @@ __glXDRIdrawableCopySubBuffer(__GLXdrawa
int x, int y, int w, int h)
{
__GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate;
+ __GLXDRIscreen *screen = (__GLXDRIscreen *)
+ __glXgetActiveScreen(basePrivate->pDraw->pScreen->myNum);
- __glXDRIdrawableFoo(private);
-
- (*private->driDrawable->copySubBuffer)(NULL,
- private->driDrawable->private,
- x, y, w, h);
+ if (screen->copySubBuffer)
+ screen->copySubBuffer->copySubBuffer(&private->driDrawable,
+ x, y, w, h);
}
static void
__glXDRIcontextDestroy(__GLXcontext *baseContext)
{
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
+ Bool retval;
+
+ context->driContext.destroyContext(&context->driContext);
+
+ __glXenterServer(GL_FALSE);
+ retval = DRIDestroyContext(baseContext->pScreen, context->hwContextID);
+ __glXleaveServer(GL_FALSE);
- context->driContext.destroyContext(NULL,
- context->base.pScreen->myNum,
- context->driContext.private);
__glXContextDestroy(&context->base);
xfree(context);
}
@@ -292,24 +247,20 @@ static int
__glXDRIcontextMakeCurrent(__GLXcontext *baseContext)
{
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
+ __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
+ __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
- return (*context->driContext.bindContext)(NULL,
- context->base.pScreen->myNum,
- baseContext->drawPriv->drawId,
- baseContext->readPriv->drawId,
- &context->driContext);
-}
+ return (*context->driContext.bindContext)(&context->driContext,
+ &draw->driDrawable,
+ &read->driDrawable);
+}
static int
__glXDRIcontextLoseCurrent(__GLXcontext *baseContext)
{
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
- return (*context->driContext.unbindContext)(NULL,
- context->base.pScreen->myNum,
- baseContext->drawPriv->drawId,
- baseContext->readPriv->drawId,
- &context->driContext);
+ return (*context->driContext.unbindContext)(&context->driContext);
}
static int
@@ -331,12 +282,12 @@ static int
__glXDRIcontextForceCurrent(__GLXcontext *baseContext)
{
__GLXDRIcontext *context = (__GLXDRIcontext *) baseContext;
+ __GLXDRIdrawable *draw = (__GLXDRIdrawable *) baseContext->drawPriv;
+ __GLXDRIdrawable *read = (__GLXDRIdrawable *) baseContext->readPriv;
- return (*context->driContext.bindContext)(NULL,
- context->base.pScreen->myNum,
- baseContext->drawPriv->drawId,
- baseContext->readPriv->drawId,
- &context->driContext);
+ return (*context->driContext.bindContext)(&context->driContext,
+ &draw->driDrawable,
+ &read->driDrawable);
}
static void
@@ -390,7 +341,7 @@ __glXDRIbindTexImage(__GLXcontext *baseC
pixmap = (PixmapPtr) glxPixmap->pDraw;
- if (screen->texOffsetStart && screen->driScreen.setTexOffset) {
+ if (screen->texOffsetStart && screen->texOffset) {
__GLXpixmap **texOffsetOverride = screen->texOffsetOverride;
int i, firstEmpty = 16;
@@ -422,8 +373,9 @@ alreadyin:
glxPixmap->texname = texname;
- screen->driScreen.setTexOffset(glxPixmap->pDRICtx, texname, 0,
- pixmap->drawable.depth, pixmap->devKind);
+ screen->texOffset->setTexOffset(glxPixmap->pDRICtx, texname, 0,
+ pixmap->drawable.depth,
+ pixmap->devKind);
}
nooverride:
@@ -575,9 +527,7 @@ __glXDRIscreenDestroy(__GLXscreen *baseS
{
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
- screen->driScreen.destroyScreen(NULL,
- screen->base.pScreen->myNum,
- screen->driScreen.private);
+ screen->driScreen.destroyScreen(&screen->driScreen);
dlclose(screen->driver);
@@ -593,13 +543,18 @@ __glXDRIscreenCreateContext(__GLXscreen
{
__GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen;
__GLXDRIcontext *context, *shareContext;
- void *sharePrivate;
+ VisualPtr visual;
+ int i;
+ GLboolean retval;
+ __DRIcontext *driShare;
+ drm_context_t hwContext;
+ ScreenPtr pScreen = baseScreen->pScreen;
shareContext = (__GLXDRIcontext *) baseShareContext;
if (shareContext)
- sharePrivate = shareContext->driContext.private;
+ driShare = &shareContext->driContext;
else
- sharePrivate = NULL;
+ driShare = NULL;
context = xalloc(sizeof *context);
if (context == NULL)
@@ -614,15 +569,29 @@ __glXDRIscreenCreateContext(__GLXscreen
context->base.pScreen = screen->base.pScreen;
context->base.textureFromPixmap = &__glXDRItextureFromPixmap;
+ /* Find the requested X visual */
+ visual = pScreen->visuals;
+ for (i = 0; i < pScreen->numVisuals; i++, visual++)
+ if (visual->vid == modes->visualID)
+ break;
+ if (i == pScreen->numVisuals)
+ return GL_FALSE;
+
+ context->hwContextID = FakeClientID(0);
+
+ __glXenterServer(GL_FALSE);
+ retval = DRICreateContext(baseScreen->pScreen, visual,
+ context->hwContextID, &hwContext);
+ __glXleaveServer(GL_FALSE);
context->driContext.private =
- screen->driScreen.createNewContext(NULL, modes,
+ screen->driScreen.createNewContext(&screen->driScreen,
+ modes,
0, /* render type */
- sharePrivate,
+ driShare,
+ hwContext,
&context->driContext);
- context->driContext.mode = modes;
-
return &context->base;
}
@@ -632,7 +601,10 @@ __glXDRIscreenCreateDrawable(__GLXscreen
XID drawId,
__GLcontextModes *modes)
{
+ __GLXDRIscreen *driScreen = (__GLXDRIscreen *) screen;
__GLXDRIdrawable *private;
+ GLboolean retval;
+ drm_drawable_t hwDrawable;
private = xalloc(sizeof *private);
if (private == NULL)
@@ -650,21 +622,19 @@ __glXDRIscreenCreateDrawable(__GLXscreen
private->base.swapBuffers = __glXDRIdrawableSwapBuffers;
private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer;
-#if 0
- /* FIXME: It would only be natural that we called
- * driScreen->createNewDrawable here but the DRI drivers manage
- * them a little oddly. FIXME: describe this better.*/
+ __glXenterServer(GL_FALSE);
+ retval = DRICreateDrawable(screen->pScreen, serverClient,
+ pDraw, &hwDrawable);
+ __glXleaveServer(GL_FALSE);
/* The last argument is 'attrs', which is used with pbuffers which
* we currently don't support. */
- glxPriv->driDrawable.private =
- (screen->driScreen.createNewDrawable)(NULL, modes,
- drawId,
- &glxPriv->driDrawable,
- 0,
- NULL);
-#endif
+ private->driDrawable.private =
+ (driScreen->driScreen.createNewDrawable)(&driScreen->driScreen,
+ modes,
+ &private->driDrawable,
+ hwDrawable, 0, NULL);
return &private->base;
}
@@ -727,161 +697,31 @@ filter_modes(__GLcontextModes **server_m
}
-static void
-enable_glx_extension(void *psc, const char *ext_name)
-{
- __GLXDRIscreen * const screen = (__GLXDRIscreen *) psc;
-
- __glXEnableExtension(screen->glx_enable_bits, ext_name);
-}
-
-
-static __DRIfuncPtr getProcAddress(const char *proc_name)
-{
- if (strcmp(proc_name, "glxEnableExtension") == 0) {
- return (__DRIfuncPtr) enable_glx_extension;
- }
-
- return NULL;
-}
-
-static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn)
-{
- __GLXDRIscreen *screen = (__GLXDRIscreen *) __glXgetActiveScreen(scrn);
-
- return &screen->driScreen;
-}
-
-static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw)
-{
- DrawablePtr pDrawable = (DrawablePtr) LookupIDByType(draw, RT_WINDOW);
- int unused;
- drm_clip_rect_t *pRects;
-
- return pDrawable ? DRIGetDrawableInfo(pDrawable->pScreen, pDrawable,
- (unsigned*)&unused, (unsigned*)&unused,
- &unused, &unused, &unused, &unused,
- &unused, &pRects, &unused, &unused,
- &unused, &pRects)
- : GL_FALSE;
-}
-
-static GLboolean createContext(__DRInativeDisplay *dpy, int screen,
- int configID, void *contextID,
- drm_context_t *hw_context)
-{
- XID fakeID;
- VisualPtr visual;
- int i;
- ScreenPtr pScreen;
- GLboolean retval;
-
- pScreen = screenInfo.screens[screen];
-
- /* Find the requested X visual */
- visual = pScreen->visuals;
- for (i = 0; i < pScreen->numVisuals; i++, visual++)
- if (visual->vid == configID)
- break;
- if (i == pScreen->numVisuals)
- return GL_FALSE;
-
- fakeID = FakeClientID(0);
- *(XID *) contextID = fakeID;
-
- __glXDRIenterServer(GL_FALSE);
- retval = DRICreateContext(pScreen, visual, fakeID, hw_context);
- __glXDRIleaveServer(GL_FALSE);
- return retval;
-}
-
-static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen,
- __DRIid context)
-{
- GLboolean retval;
-
- __glXDRIenterServer(GL_FALSE);
- retval = DRIDestroyContext(screenInfo.screens[screen], context);
- __glXDRIleaveServer(GL_FALSE);
- return retval;
-}
-
-static GLboolean
-createDrawable(__DRInativeDisplay *dpy, int screen,
- __DRIid drawable, drm_drawable_t *hHWDrawable)
-{
- DrawablePtr pDrawable;
- GLboolean retval;
-
- pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
- if (!pDrawable)
- return GL_FALSE;
-
- __glXDRIenterServer(GL_FALSE);
- retval = DRICreateDrawable(screenInfo.screens[screen], __pGlxClient,
- pDrawable, hHWDrawable);
- __glXDRIleaveServer(GL_FALSE);
- return retval;
-}
+#define containerOf(ptr, type, member) \
+ (type *)( (char *)ptr - offsetof(type,member) )
static GLboolean
-destroyDrawable(__DRInativeDisplay *dpy, int screen, __DRIid drawable)
-{
- DrawablePtr pDrawable;
- GLboolean retval;
-
- pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
- if (!pDrawable)
- return GL_FALSE;
-
- __glXDRIenterServer(GL_FALSE);
- retval = DRIDestroyDrawable(screenInfo.screens[screen], __pGlxClient,
- pDrawable);
- __glXDRIleaveServer(GL_FALSE);
- return retval;
-}
-
-static GLboolean
-getDrawableInfo(__DRInativeDisplay *dpy, int screen,
- __DRIid drawable, unsigned int *index, unsigned int *stamp,
+getDrawableInfo(__DRIdrawable *driDrawable,
+ unsigned int *index, unsigned int *stamp,
int *x, int *y, int *width, int *height,
int *numClipRects, drm_clip_rect_t **ppClipRects,
int *backX, int *backY,
int *numBackClipRects, drm_clip_rect_t **ppBackClipRects)
{
- DrawablePtr pDrawable;
+ __GLXDRIdrawable *drawable = containerOf(driDrawable,
+ __GLXDRIdrawable, driDrawable);
+ ScreenPtr pScreen = drawable->base.pDraw->pScreen;
drm_clip_rect_t *pClipRects, *pBackClipRects;
GLboolean retval;
size_t size;
- pDrawable = (DrawablePtr) LookupIDByClass(drawable, RC_DRAWABLE);
- if (!pDrawable) {
- ErrorF("getDrawableInfo failed to look up window\n");
-
- *index = 0;
- *stamp = 0;
- *x = 0;
- *y = 0;
- *width = 0;
- *height = 0;
- *numClipRects = 0;
- *ppClipRects = NULL;
- *backX = 0;
- *backY = 0;
- *numBackClipRects = 0;
- *ppBackClipRects = NULL;
-
- return GL_FALSE;
- }
-
- __glXDRIenterServer(GL_FALSE);
- retval = DRIGetDrawableInfo(screenInfo.screens[screen],
- pDrawable, index, stamp,
+ __glXenterServer(GL_FALSE);
+ retval = DRIGetDrawableInfo(pScreen, drawable->base.pDraw, index, stamp,
x, y, width, height,
numClipRects, &pClipRects,
backX, backY,
numBackClipRects, &pBackClipRects);
- __glXDRIleaveServer(GL_FALSE);
+ __glXleaveServer(GL_FALSE);
if (*numClipRects > 0) {
size = sizeof (drm_clip_rect_t) * *numClipRects;
@@ -889,7 +729,6 @@ getDrawableInfo(__DRInativeDisplay *dpy,
/* Clip cliprects to screen dimensions (redirected windows) */
if (*ppClipRects != NULL) {
- ScreenPtr pScreen = screenInfo.screens[screen];
int i, j;
for (i = 0, j = 0; i < *numClipRects; i++) {
@@ -948,19 +787,9 @@ getUST(int64_t *ust)
/* Table of functions that we export to the driver. */
static const __DRIinterfaceMethods interface_methods = {
- getProcAddress,
-
_gl_context_modes_create,
_gl_context_modes_destroy,
-
- findScreen,
- windowExists,
-
- createContext,
- destroyContext,
- createDrawable,
- destroyDrawable,
getDrawableInfo,
getUST,
@@ -996,6 +825,48 @@ glxDRILeaveVT (int index, int flags)
return (*screen->leaveVT) (index, flags);
}
+static void
+initializeExtensions(__GLXDRIscreen *screen)
+{
+ const __DRIextension **extensions;
+ int i;
+
+ extensions = screen->driScreen.getExtensions(&screen->driScreen);
+ for (i = 0; extensions[i]; i++) {
+#ifdef __DRI_COPY_SUB_BUFFER
+ if (strcmp(extensions[i]->name, __DRI_COPY_SUB_BUFFER) == 0) {
+ screen->copySubBuffer = (__DRIcopySubBufferExtension *) extensions[i];
+ __glXEnableExtension(screen->glx_enable_bits,
+ "GLX_MESA_copy_sub_buffer");
+
+ LogMessage(X_INFO, "AIGLX: enabled GLX_MESA_copy_sub_buffer\n");
+ }
+#endif
+
+#ifdef __DRI_SWAP_CONTROL
+ if (strcmp(extensions[i]->name, __DRI_SWAP_CONTROL) == 0) {
+ screen->swapControl = (__DRIswapControlExtension *) extensions[i];
+ __glXEnableExtension(screen->glx_enable_bits,
+ "GLX_SGI_swap_control");
+ __glXEnableExtension(screen->glx_enable_bits,
+ "GLX_MESA_swap_control");
+
+ LogMessage(X_INFO, "AIGLX: enabled GLX_SGI_swap_control and GLX_MESA_swap_control\n");
+ }
+#endif
+
+#ifdef __DRI_TEX_OFFSET
+ if (strcmp(extensions[i]->name, __DRI_TEX_OFFSET) == 0) {
+ screen->texOffset = (__DRItexOffsetExtension *) extensions[i];
+ LogMessage(X_INFO, "AIGLX: enabled GLX_texture_from_pixmap with driver support\n");
+ }
+#endif
+ /* Ignore unknown extensions */
+ }
+}
+
+#define COPY_SUB_BUFFER_INTERNAL_VERSION 20060314
+
static __GLXscreen *
__glXDRIscreenProbe(ScreenPtr pScreen)
{
@@ -1044,8 +915,6 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
screen->base.pScreen = pScreen;
__glXInitExtensionEnableBits(screen->glx_enable_bits);
- screen->driScreen.screenConfigs = screen;
-
/* DRI protocol version. */
dri_version.major = XF86DRI_MAJOR_VERSION;
@@ -1170,9 +1039,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
driver_modes = NULL;
screen->driScreen.private =
- (*createNewScreen)(NULL, pScreen->myNum,
+ (*createNewScreen)(pScreen->myNum,
&screen->driScreen,
- screen->base.modes,
&ddx_version,
&dri_version,
&drm_version,
@@ -1191,6 +1059,8 @@ __glXDRIscreenProbe(ScreenPtr pScreen)
DRIGetTexOffsetFuncs(pScreen, &screen->texOffsetStart,
&screen->texOffsetFinish);
+ initializeExtensions(screen);
+
__glXScreenInit(&screen->base, pScreen);
buffer_size = __glXGetExtensionString(screen->glx_enable_bits, NULL);
diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c
index b35175e..5b621d3 100644
--- a/GL/glx/glxext.c
+++ b/GL/glx/glxext.c
@@ -145,7 +145,6 @@ static int ClientGone(int clientIndex, X
for (i=0; i < cl->numCurrentContexts; i++) {
cx = cl->currentContexts[i];
if (cx) {
- __glXDeassociateContext(cx);
cx->isCurrent = GL_FALSE;
if (!cx->idExists) {
__glXFreeContext(cx);
More information about the xorg-commit
mailing list