diff options
52 files changed, 2718 insertions, 3942 deletions
@@ -1,3 +1,121 @@ +2006-03-10 Kristian Høgsberg <krh@redhat.com> + + * Merge accel_indirect branch to HEAD. + +2006-03-05 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxcmds.c (DoGetDrawableAttributes): Add + GLX_Y_INVERTED_EXT to the drawable attributes we report. + +2006-03-05 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxcmds.c (__glXCreateARGBConfig): Create the fbconfig + for the composite 32 visual after the fact here. + + * GL/glx/glxdri.c (__glXDRIbindTexImage): Use 4bpp for 32 bit + visuals too, but only fill the alpha channel for 24 depth + drawables. + +2006-03-03 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxdri.c (getDrawableInfo): Work around i915 driver that + tries to render to drawable even if it no longer exists. + Returning 0 cliprects (as dri_util.c does) doesn't seem to do it, + so we set the width and height to 0. + + * GL/glx/g_disptab.h: + * GL/glx/glxcmdsswap.c: Fix a couple of warnings. + +2006-03-03 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxdri.c (__glXDRIscreenProbe): Log full DRI driver path + when dlopen() fails. + + * GL/glx/glxscreens.c (__glXInitScreens): Log the provider name + when we initialize a GLX screen. + + * GL/symlink-mesa.sh: + * GL/mesa/swrast/Makefile.am: Update to work with mesa head. + +2006-03-01 Kevin E. Martin <kem-at-freedesktop-dot-org> + + * GL/glx/glxdri.c: (__glXDRIscreenProbe): + Pass err_msg when dev_priv allocation fails. + +2006-03-01 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxdri.c (__glXDRIscreenProbe): Handle failing allocation + of dev_priv. + + * GL/glx/glxdri.c (__glXDRIscreenProbe): The DRI driver + _mesa_free()'s the dev_priv passed in so we need to give it a + copy. + +2006-03-01 Kevin E. Martin <kem-at-freedesktop-dot-org> + + * GL/glx/glxserver.h: + Fix Xvfb, Xnest and Xprt build. + +2006-02-28 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxdri.c (__glXDRIscreenProbe): Fix enter/leave confusion. + + * configure.ac: + * hw/xfree86/common/xf86Config.c (configServerFlags): Enable AIGLX + by default at configure time and at runtime. + +2006-02-27 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxserver.h: + * GL/glx/glxext.c: + * GL/mesa/X/xf86glx.c: Complete the prepare/finish dispatch to + enter/leave server rename. + + * GL/glx/glxcmdsswap.c (__glXSwapGetDrawableAttributesSGIX): Add + byte swapping function. + + * GL/mesa/swrast/Makefile.am (INCLUDES): Add -I../shader/slang. + + * GL/glx/glxcmds.c: Make GLX_EXT_texture_from_pixmap entrypoints + non-static so we can get at them from glxcmdsswap.c. + +2006-02-25 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxcmds.c: Add more GLX_EXT_texture_from_pixmap tokens + here as a temporary fix. + +2006-02-24 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxcmds.c: + * GL/glx/glxcmdsswap.c: + * GL/glx/glxcontext.h: + * GL/glx/glxdri.c: + * GL/glx/glxscreens.c: + * GL/glx/glxserver.h: Add hooks for GLX_EXT_texture_from_pixmap + and port over naive glTexImage2D implementation. Add support for + glXQueryDrawable. + +2006-02-24 Kevin E. Martin <kem-at-freedesktop-dot-org> + + * GL/glx/Makefile.am: + Include from Mesa sources before any installed versions. + + * GL/glx/glxdri.c: (__glXDRIleaveServer), (__glXDRIenterServer), + (createContext), (destroyContext), (createDrawable), + (destroyDrawable), (getDrawableInfo), (__glXDRIscreenProbe): + Wrap the __DRIinterfaceMethods methods with enter/leaveServer to + make sure server locks are held when calling into the card driver. + +2006-02-24 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/glxdri.c: + * GL/glx/glxvisuals.c: Add these files. + +2006-02-24 Kristian Høgsberg <krh@redhat.com> + + * GL/glx/*: Land rewritten accelerated indirect rendering on + accel_indirect_branch. + 2006-03-10 Alan Coopersmith <alan.coopersmith@sun.com> * hw/xfree86/utils/xorgcfg/help.c: diff --git a/GL/glx/Makefile.am b/GL/glx/Makefile.am index db2708335..7892dd9e5 100644 --- a/GL/glx/Makefile.am +++ b/GL/glx/Makefile.am @@ -1,10 +1,16 @@ -noinst_LTLIBRARIES = libglx.la +if AIGLX +GLXDRI_LIBRARY = libglxdri.la +endif + +noinst_LTLIBRARIES = libglx.la $(GLXDRI_LIBRARY) AM_CFLAGS = \ + -I@MESA_SOURCE@/include \ @DIX_CFLAGS@ \ @GL_CFLAGS@ \ @XLIB_CFLAGS@ \ - -I@MESA_SOURCE@/include \ + @LIBDRM_CFLAGS@ \ + @DRIPROTO_CFLAGS@ \ -I@MESA_SOURCE@/src/mesa/glapi \ -I@MESA_SOURCE@/src/mesa/main \ @SERVER_DEFINES@ \ @@ -15,10 +21,20 @@ AM_CFLAGS = \ # none yet #sdk_HEADERS = -INCLUDES = -I$(top_srcdir)/GL/include -I$(top_srcdir)/hw/xfree86/os-support +INCLUDES = \ + -I$(top_srcdir)/GL/include \ + -I$(top_srcdir)/hw/xfree86/os-support \ + -I$(top_srcdir)/hw/xfree86/os-support/bus \ + -I$(top_srcdir)/hw/xfree86/common \ + -I$(top_srcdir)/hw/xfree86/dri \ + -I$(top_srcdir)/mi + nodist_libglx_la_SOURCES = indirect_size.h +libglxdri_la_SOURCES = \ + glxdri.c + libglx_la_SOURCES = \ g_disptab.c \ g_disptab.h \ @@ -29,8 +45,6 @@ libglx_la_SOURCES = \ glcontextmodes.h \ global.c \ glthread.c \ - glxbuf.c \ - glxbuf.h \ glxcmds.c \ glxcmdsswap.c \ glxcontext.h \ @@ -38,14 +52,7 @@ libglx_la_SOURCES = \ glxerror.h \ glxext.c \ glxext.h \ - glxfb.c \ - glxfb.h \ - glximports.c \ - glximports.h \ - glxmem.c \ - glxmem.h \ - glxpix.c \ - glxpix.h \ + glxvisuals.c \ glxscreens.c \ glxscreens.h \ glxserver.h \ diff --git a/GL/glx/g_disptab.h b/GL/glx/g_disptab.h index 222c5164e..9ae901c1d 100644 --- a/GL/glx/g_disptab.h +++ b/GL/glx/g_disptab.h @@ -46,6 +46,9 @@ extern int __glXWaitGL(__GLXclientState*, GLbyte*); extern int __glXWaitX(__GLXclientState*, GLbyte*); extern int __glXCopyContext(__GLXclientState*, GLbyte*); extern int __glXSwapBuffers(__GLXclientState*, GLbyte*); +extern int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc); extern int __glXUseXFont(__GLXclientState*, GLbyte*); extern int __glXCreateGLXPixmap(__GLXclientState*, GLbyte*); extern int __glXGetVisualConfigs(__GLXclientState*, GLbyte*); @@ -71,6 +74,9 @@ extern int __glXSwapWaitGL(__GLXclientState*, GLbyte*); extern int __glXSwapWaitX(__GLXclientState*, GLbyte*); extern int __glXSwapCopyContext(__GLXclientState*, GLbyte*); extern int __glXSwapSwapBuffers(__GLXclientState*, GLbyte*); +extern int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); +extern int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc); extern int __glXSwapUseXFont(__GLXclientState*, GLbyte*); extern int __glXSwapCreateGLXPixmap(__GLXclientState*, GLbyte*); extern int __glXSwapGetVisualConfigs(__GLXclientState*, GLbyte*); diff --git a/GL/glx/global.c b/GL/glx/global.c index 18cd5edc2..28030ec03 100644 --- a/GL/glx/global.c +++ b/GL/glx/global.c @@ -53,6 +53,7 @@ __GLXcontext *__glXLastContext; RESTYPE __glXContextRes; RESTYPE __glXClientRes; RESTYPE __glXPixmapRes; +RESTYPE __glXDrawableRes; RESTYPE __glXSwapBarrierRes; /* diff --git a/GL/glx/glxbuf.c b/GL/glx/glxbuf.c deleted file mode 100644 index 44be53614..000000000 --- a/GL/glx/glxbuf.c +++ /dev/null @@ -1,296 +0,0 @@ -/* $XFree86: xc/programs/Xserver/GL/glx/glxbuf.c,v 1.6 2001/03/25 05:32:01 tsi Exp $ */ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#include "glxserver.h" -#include "glxutil.h" -#include "glxbuf.h" -#include "glxfb.h" -#include "glxmem.h" -#include "glxpix.h" - -void -__glXFBInitDrawable(__GLXdrawablePrivate *glxPriv, __GLcontextModes *modes) -{ - __GLdrawablePrivate *glPriv; - GLint rgbBits; - GLint accumBits; - - glPriv = &glxPriv->glPriv; - rgbBits = modes->rgbBits; - accumBits = modes->accumRedBits + modes->accumGreenBits + - modes->accumBlueBits + modes->accumAlphaBits; - -#if defined(__GL_ALIGNED_BUFFERS) - /* initialize pixel alignments (for more details see context.h) */ - glPriv->xAlignment = 1; - glPriv->yAlignment = 1; -#endif - - glxPriv->swapBuffers = __glXFBMemSwapBuffers; - - glPriv->yInverted = GL_TRUE; /* Y is upside-down */ - - if (modes->doubleBufferMode) { - if (modes->colorIndexMode) { - __glXInitFB(&glPriv->frontBuffer, glPriv, modes->indexBits); - __glXInitMem(&glPriv->backBuffer, glPriv, modes->indexBits); - } else { - __glXInitFB(&glPriv->frontBuffer, glPriv, rgbBits); - __glXInitMem(&glPriv->backBuffer, glPriv, rgbBits); - } - } else { - if (modes->colorIndexMode) { - __glXInitFB(&glPriv->frontBuffer, glPriv, modes->indexBits); - } else { - __glXInitFB(&glPriv->frontBuffer, glPriv, rgbBits); - } - } - -#if defined(__GL_MAX_AUXBUFFERS) && (__GL_MAX_AUXBUFFERS > 0) - if (modes->maxAuxBuffers > 0) { - GLint i; - - for (i=0; i < modes->maxAuxBuffers; i++) { - if (modes->colorIndexMode) { - __glXInitMem(&glPriv->auxBuffer[i], glPriv, modes->indexBits); - } else { - __glXInitMem(&glPriv->auxBuffer[i], glPriv, rgbBits); - } - } - } -#endif - - if (modes->haveAccumBuffer) { - __glXInitMem(&glPriv->accumBuffer, glPriv, accumBits); - } - if (modes->haveDepthBuffer) { - __glXInitMem(&glPriv->depthBuffer, glPriv, modes->depthBits); - } - if (modes->haveStencilBuffer) { - __glXInitMem(&glPriv->stencilBuffer, glPriv, modes->stencilBits); - } -} - -void -__glXPixInitDrawable(__GLXdrawablePrivate *glxPriv, __GLcontextModes *modes) -{ - __GLdrawablePrivate *glPriv; - GLint rgbBits; - GLint accumBits; - - assert(glxPriv->pGlxPixmap); - - glPriv = &glxPriv->glPriv; - rgbBits = modes->rgbBits; - accumBits = modes->accumRedBits + modes->accumGreenBits + - modes->accumBlueBits + modes->accumAlphaBits; - -#if defined(__GL_ALIGNED_BUFFERS) - /* initialize pixel alignments (for more details see context.h) */ - glPriv->xAlignment = 1; - glPriv->yAlignment = 1; -#endif - - glxPriv->swapBuffers = (GLboolean (*)(__GLXdrawablePrivate *))__glXNop; - - glPriv->yInverted = GL_FALSE; - - if (modes->doubleBufferMode) { - if (modes->colorIndexMode) { - __glXInitPix(&glPriv->frontBuffer, glPriv, rgbBits, - glxPriv->drawId, glxPriv->pGlxPixmap); - __glXInitMem(&glPriv->backBuffer, glPriv, modes->indexBits); - } else { - __glXInitPix(&glPriv->frontBuffer, glPriv, rgbBits, - glxPriv->drawId, glxPriv->pGlxPixmap); - __glXInitMem(&glPriv->backBuffer, glPriv, rgbBits); - } - } else { - if (modes->colorIndexMode) { - __glXInitPix(&glPriv->frontBuffer, glPriv, rgbBits, - glxPriv->drawId, glxPriv->pGlxPixmap); - } else { - __glXInitPix(&glPriv->frontBuffer, glPriv, rgbBits, - glxPriv->drawId, glxPriv->pGlxPixmap); - } - } - -#if defined(__GL_MAX_AUXBUFFERS) && (__GL_MAX_AUXBUFFERS > 0) - if (modes->maxAuxBuffers > 0) { - GLint i; - - for (i=0; i < modes->maxAuxBuffers; i++) { - if (modes->colorIndexMode) { - __glXInitMem(&glPriv->auxBuffer[i], glPriv, modes->indexBits); - } else { - __glXInitMem(&glPriv->auxBuffer[i], glPriv, rgbBits); - } - } - } -#endif - - if (modes->haveAccumBuffer) { - __glXInitMem(&glPriv->accumBuffer, glPriv, accumBits); - } - if (modes->haveDepthBuffer) { - __glXInitMem(&glPriv->depthBuffer, glPriv, modes->depthBits); - } - if (modes->haveStencilBuffer) { - __glXInitMem(&glPriv->stencilBuffer, glPriv, modes->stencilBits); - } -} - - -#define __GLX_SET_ACCEL_BUFFER_MASK(bm) \ - if (status == GL_FALSE) return GL_FALSE; \ - if (status == GL_TRUE) accelBufferMask |= bm; \ - /* for __GL_BUFFER_FALLBACK don't do anything */ - -GLboolean -__glXResizeBuffers(__GLdrawablePrivate *glPriv, - GLint x, GLint y, GLuint width, GLuint height) -{ - __GLcontextModes *modes; - __GLdrawableRegion *glRegion; - GLboolean status; - GLuint accelBufferMask; - - modes = glPriv->modes; - accelBufferMask = 0; - - status = (*glPriv->frontBuffer.resize)(&glPriv->frontBuffer, - x, y, width, height, glPriv, - __GL_FRONT_BUFFER_MASK); - __GLX_SET_ACCEL_BUFFER_MASK(__GL_FRONT_BUFFER_MASK); - - if (modes->doubleBufferMode) { - status = (*glPriv->backBuffer.resize)(&glPriv->backBuffer, - x, y, width, height, glPriv, - __GL_BACK_BUFFER_MASK); - __GLX_SET_ACCEL_BUFFER_MASK(__GL_BACK_BUFFER_MASK); - } - -#if defined(__GL_MAX_AUXBUFFERS) && (__GL_MAX_AUXBUFFERS > 0) - if (modes->maxAuxBuffers > 0) { - GLint i; - - for (i=0; i < modes->maxAuxBuffers; i++) { - status = (*glPriv->auxBuffers[i].resize)(&glPriv->auxBuffer[i], - x, y, width, height, - glPriv, - __GL_AUX_BUFFER_MASK(i)); - __GLX_SET_ACCEL_BUFFER_MASK(__GL_AUX_BUFFER_MASK(i)); - } - } -#endif - - if (modes->haveAccumBuffer) { - status = (*glPriv->accumBuffer.resize)(&glPriv->accumBuffer, - x, y, width, height, glPriv, - __GL_ACCUM_BUFFER_MASK); - __GLX_SET_ACCEL_BUFFER_MASK(__GL_ACCUM_BUFFER_MASK); - } - - if (modes->haveDepthBuffer) { - status = (*glPriv->depthBuffer.resize)(&glPriv->depthBuffer, - x, y, width, height, glPriv, - __GL_DEPTH_BUFFER_MASK); - __GLX_SET_ACCEL_BUFFER_MASK(__GL_DEPTH_BUFFER_MASK); - } - - if (modes->haveStencilBuffer) { - status = (*glPriv->stencilBuffer.resize)(&glPriv->stencilBuffer, - x, y, width, height, glPriv, - __GL_STENCIL_BUFFER_MASK); - __GLX_SET_ACCEL_BUFFER_MASK(__GL_STENCIL_BUFFER_MASK); - } - - glPriv->accelBufferMask = accelBufferMask; - - /* finally, update the ownership region */ - glRegion = &glPriv->ownershipRegion; - glRegion->numRects = 1; - glRegion->rects[0].x0 = 0; - glRegion->rects[0].y0 = 0; - glRegion->rects[0].x1 = width; - glRegion->rects[0].y1 = height; - - return GL_TRUE; -} - -void -__glXFreeBuffers(__GLXdrawablePrivate *glxPriv) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; -#if defined(__GL_MAX_AUXBUFFERS) && (__GL_MAX_AUXBUFFERS > 0) - __GLcontextModes *modes = glPriv->modes; -#endif - - if (glPriv->frontBuffer.free) { - (*glPriv->frontBuffer.free)(&glPriv->frontBuffer, glPriv); - } - if (glPriv->backBuffer.free) { - (*glPriv->backBuffer.free)(&glPriv->backBuffer, glPriv); - } - -#if defined(__GL_MAX_AUXBUFFERS) && (__GL_MAX_AUXBUFFERS > 0) - if (modes->maxAuxBuffers > 0) { - GLint i; - - for (i=0; i < modes->maxAuxBuffers; i++) { - if (glPriv->auxBuffer[i].free) { - (*glPriv->auxBuffer[i].free)(&glPriv->auxBuffer[i], glPriv); - } - } - } -#endif - - if (glPriv->accumBuffer.free) { - (*glPriv->accumBuffer.free)(&glPriv->accumBuffer, glPriv); - } - - if (glPriv->depthBuffer.free) { - (*glPriv->depthBuffer.free)(&glPriv->depthBuffer, glPriv); - } - - if (glPriv->stencilBuffer.free) { - (*glPriv->stencilBuffer.free)(&glPriv->stencilBuffer, glPriv); - } -} diff --git a/GL/glx/glxbuf.h b/GL/glx/glxbuf.h deleted file mode 100644 index 88b04e8bd..000000000 --- a/GL/glx/glxbuf.h +++ /dev/null @@ -1,57 +0,0 @@ -/* $XFree86$ */ -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#ifndef _glxbuf_h_ -#define _glxbuf_h_ - -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -extern void __glXFBInitDrawable(__GLXdrawablePrivate *glxPriv, - __GLcontextModes *modes); -extern void __glXPixInitDrawable(__GLXdrawablePrivate *glxPriv, - __GLcontextModes *modes); - -extern GLboolean __glXResizeBuffers(__GLdrawablePrivate *glPriv, - GLint x, GLint y, - GLuint width, GLuint height); - -extern void __glXFreeBuffers(__GLXdrawablePrivate *glxPriv); -extern void __glXUpdatePalette(__GLXdrawablePrivate *); - -#endif /* _glxbuf_h_ */ - diff --git a/GL/glx/glxcmds.c b/GL/glx/glxcmds.c index c63b17008..6426e294e 100644 --- a/GL/glx/glxcmds.c +++ b/GL/glx/glxcmds.c @@ -49,7 +49,6 @@ #include <pixmapstr.h> #include <windowstr.h> #include "g_disptab_EXT.h" -#include "glximports.h" #include "glxutil.h" #include "glxext.h" #include "GL/glx_ansic.h" @@ -61,24 +60,6 @@ /************************************************************************/ -static __GLimports imports = { - __glXImpMalloc, - __glXImpCalloc, - __glXImpRealloc, - __glXImpFree, - __glXImpWarning, - __glXImpFatal, - __glXImpGetenv, - __glXImpAtoi, - __glXImpSprintf, - __glXImpFopen, - __glXImpFclose, - __glXImpFprintf, - __glXImpGetDrawablePrivate, - __glXImpGetReadablePrivate, - NULL -}; - static int __glXGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc); static int __glXCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc); static int __glXCreateGLXPixmapWithConfigSGIX(__GLXclientState *cl, GLbyte *pc); @@ -94,6 +75,27 @@ static int __glxHyperpipeConfigSGIX(__GLXclientState *cl, GLbyte *pc); /************************************************************************/ +static void __glXdirectContextDestroy(__GLXcontext *context) +{ + __glXFree(context); +} + +static __GLXcontext *__glXdirectContextCreate(__GLXscreen *screen, + __GLcontextModes *modes, + __GLXcontext *shareContext) +{ + __GLXcontext *context; + + context = __glXMalloc (sizeof (__GLXcontext)); + if (context == NULL) + return NULL; + + memset(context, 0, sizeof *context); + context->destroy = __glXdirectContextDestroy; + + return context; +} + /** * Create a GL context with the given properties. This routine is used * to implement \c glXCreateContext, \c glXCreateNewContext, and @@ -111,8 +113,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, ScreenPtr pScreen; __GLXcontext *glxc, *shareglxc; __GLcontextModes *modes; - __GLXscreenInfo *pGlxScreen; - __GLinterface *shareGC; + __GLXscreen *pGlxScreen; GLint i; LEGAL_NEW_RESOURCE(gcId, client); @@ -125,7 +126,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, return BadValue; } pScreen = screenInfo.screens[screen]; - pGlxScreen = &__glXActiveScreens[screen]; + pGlxScreen = __glXActiveScreens[screen]; /* ** Check if the visual ID is valid for this screen. @@ -167,7 +168,7 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, ** for multithreaded servers, we don't do this. */ if (shareList == None) { - shareGC = 0; + shareglxc = 0; } else { shareglxc = (__GLXcontext *) LookupIDByType(shareList, __glXContextRes); if (!shareglxc) { @@ -193,17 +194,18 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, */ isDirect = GL_FALSE; } - shareGC = shareglxc->gc; } /* ** Allocate memory for the new context */ - glxc = (__GLXcontext *) __glXMalloc(sizeof(__GLXcontext)); + if (!isDirect) + glxc = pGlxScreen->createContext(pGlxScreen, modes, shareglxc); + else + glxc = __glXdirectContextCreate(pGlxScreen, modes, shareglxc); if (!glxc) { return BadAlloc; } - __glXMemset(glxc, 0, sizeof(__GLXcontext)); /* ** Initially, setup the part of the context that could be used by @@ -214,32 +216,11 @@ int DoCreateContext(__GLXclientState *cl, GLXContextID gcId, glxc->pVisual = pVisual; glxc->modes = modes; - if (!isDirect) { - - /* - ** Allocate a GL context - */ - imports.other = (void *)glxc; - glxc->gc = (*pGlxScreen->createContext)(&imports, glxc->modes, shareGC); - if (!glxc->gc) { - __glXFree(glxc); - client->errorValue = gcId; - return BadAlloc; - } - } else { - /* - ** Don't need local GL context for a direct context. - */ - glxc->gc = 0; - } /* ** Register this context as a resource. */ if (!AddResource(gcId, __glXContextRes, (pointer)glxc)) { - if (!isDirect) { - (*glxc->gc->exports.destroyContext)((__GLcontext *)glxc->gc); - } - __glXFree(glxc); + (*glxc->destroy)(glxc); client->errorValue = gcId; return BadAlloc; } @@ -520,9 +501,8 @@ int DoMakeCurrent( __GLXclientState *cl, __GLXpixmap *drawPixmap = NULL; __GLXpixmap *readPixmap = NULL; __GLXcontext *glxc, *prevglxc; - __GLinterface *gc, *prevgc; - __GLXdrawablePrivate *drawPriv = NULL; - __GLXdrawablePrivate *readPriv = NULL; + __GLXdrawable *drawPriv = NULL; + __GLXdrawable *readPriv = NULL; GLint error; GLuint mask; @@ -554,10 +534,8 @@ int DoMakeCurrent( __GLXclientState *cl, client->errorValue = prevglxc->id; return __glXBadContextState; } - prevgc = prevglxc->gc; } else { prevglxc = 0; - prevgc = 0; } /* @@ -575,8 +553,6 @@ int DoMakeCurrent( __GLXclientState *cl, /* Context is current to somebody else */ return BadAccess; } - gc = glxc->gc; - assert( drawId != None ); assert( readId != None ); @@ -600,14 +576,14 @@ int DoMakeCurrent( __GLXclientState *cl, /* FIXME: Finish refactoring this. - idr */ /* get the drawable private */ if (pDraw) { - drawPriv = __glXGetDrawablePrivate(pDraw, drawId, glxc->modes); + drawPriv = __glXGetDrawable(glxc, pDraw, drawId); if (drawPriv == NULL) { return __glXBadDrawable; } } if (pRead != pDraw) { - readPriv = __glXGetDrawablePrivate(pRead, readId, glxc->modes); + readPriv = __glXGetDrawable(glxc, pRead, readId); if (readPriv == NULL) { return __glXBadDrawable; } @@ -618,7 +594,6 @@ int DoMakeCurrent( __GLXclientState *cl, } else { /* Switching to no context. Ignore new drawable. */ glxc = 0; - gc = 0; pDraw = 0; pRead = 0; } @@ -640,7 +615,7 @@ int DoMakeCurrent( __GLXclientState *cl, /* ** Make the previous context not current. */ - if (!(*prevgc->exports.loseCurrent)((__GLcontext *)prevgc)) { + if (!(*prevglxc->loseCurrent)(prevglxc)) { return __glXBadContext; } __glXDeassociateContext(prevglxc); @@ -651,19 +626,18 @@ int DoMakeCurrent( __GLXclientState *cl, glxc->drawPriv = drawPriv; glxc->readPriv = readPriv; - __glXCacheDrawableSize(drawPriv); /* make the context current */ - if (!(*gc->exports.makeCurrent)((__GLcontext *)gc)) { + if (!(*glxc->makeCurrent)(glxc)) { glxc->drawPriv = NULL; glxc->readPriv = NULL; return __glXBadContext; } /* resize the buffers */ - if (!__glXResizeDrawableBuffers(drawPriv)) { + if (!(*drawPriv->resize)(drawPriv)) { /* could not do initial resize. make current failed */ - (*gc->exports.loseCurrent)((__GLcontext *)gc); + (*glxc->loseCurrent)(glxc); glxc->drawPriv = NULL; glxc->readPriv = NULL; return __glXBadContext; @@ -911,9 +885,7 @@ int __glXCopyContext(__GLXclientState *cl, GLbyte *pc) /* ** Issue copy. The only reason for failure is a bad mask. */ - if (!(*dst->gc->exports.copyContext)((__GLcontext *)dst->gc, - (__GLcontext *)src->gc, - mask)) { + if (!(*dst->copy)(dst, src, mask)) { client->errorValue = mask; return BadValue; } @@ -926,7 +898,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen, { ClientPtr client = cl->client; xGLXGetVisualConfigsReply reply; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; __GLcontextModes *modes; CARD32 buf[__GLX_TOTAL_CONFIG]; int p; @@ -938,7 +910,7 @@ int DoGetVisualConfigs(__GLXclientState *cl, unsigned screen, client->errorValue = screen; return BadValue; } - pGlxScreen = &__glXActiveScreens[screen]; + pGlxScreen = __glXActiveScreens[screen]; reply.numVisuals = pGlxScreen->numUsableVisuals; reply.numProps = __GLX_TOTAL_CONFIG; @@ -1017,6 +989,68 @@ int __glXGetVisualConfigs(__GLXclientState *cl, GLbyte *pc) } +/* Composite adds a 32 bit ARGB visual after glxvisuals.c have created + * the context modes for the screens. This visual is useful for GLX + * pixmaps, so we create a single mode for this visual with no extra + * buffers. */ +static void +__glXCreateARGBConfig(__GLXscreen *screen) +{ + __GLcontextModes *modes; + VisualPtr visual; + int i; + + visual = NULL; + for (i = 0; i < screen->pScreen->numVisuals; i++) + if (screen->pScreen->visuals[i].nplanes == 32) { + visual = &screen->pScreen->visuals[i]; + break; + } + + if (visual == NULL || visual->class != TrueColor) + return; + + if (_gl_context_modes_find_visual (screen->modes, visual->vid)) + return; + + /* Stop now if we already added the mode. */ + modes = _gl_context_modes_create(1, sizeof(__GLcontextModes)); + if (modes == NULL) + return; + + modes->next = screen->modes; + screen->modes = modes; + screen->numUsableVisuals++; + screen->numVisuals++; + + modes->visualID = visual->vid; + modes->fbconfigID = visual->vid; + modes->visualType = GLX_TRUE_COLOR; + modes->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT; + modes->renderType = GLX_RGBA_BIT; + modes->xRenderable = GL_TRUE; + modes->rgbMode = TRUE; + modes->colorIndexMode = FALSE; + modes->doubleBufferMode = FALSE; + modes->stereoMode = FALSE; + modes->haveAccumBuffer = FALSE; + + modes->redBits = visual->bitsPerRGBValue;; + modes->greenBits = visual->bitsPerRGBValue; + modes->blueBits = visual->bitsPerRGBValue; + modes->alphaBits = visual->bitsPerRGBValue; + + modes->rgbBits = 4 * visual->bitsPerRGBValue; + modes->indexBits = 0; + modes->level = 0; + modes->numAuxBuffers = 0; + + modes->haveDepthBuffer = FALSE; + modes->depthBits = 0; + modes->haveStencilBuffer = FALSE; + modes->stencilBits = 0; +} + #define __GLX_TOTAL_FBCONFIG_ATTRIBS (28) #define __GLX_FBCONFIG_ATTRIBS_LENGTH (__GLX_TOTAL_FBCONFIG_ATTRIBS * 2) @@ -1034,7 +1068,7 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap) { ClientPtr client = cl->client; xGLXGetFBConfigsReply reply; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; CARD32 buf[__GLX_FBCONFIG_ATTRIBS_LENGTH]; int p; __GLcontextModes *modes; @@ -1047,7 +1081,9 @@ int DoGetFBConfigs(__GLXclientState *cl, unsigned screen, GLboolean do_swap) client->errorValue = screen; return BadValue; } - pGlxScreen = &__glXActiveScreens[screen]; + pGlxScreen = __glXActiveScreens[screen]; + + __glXCreateARGBConfig(pGlxScreen); reply.numFBConfigs = pGlxScreen->numUsableVisuals; reply.numAttribs = __GLX_TOTAL_FBCONFIG_ATTRIBS; @@ -1145,7 +1181,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual, ScreenPtr pScreen; VisualPtr pVisual; __GLXpixmap *pGlxPixmap; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; __GLcontextModes *modes; int i; @@ -1188,7 +1224,7 @@ int DoCreateGLXPixmap(__GLXclientState *cl, VisualID visual, /* ** Get configuration of the visual. */ - pGlxScreen = &__glXActiveScreens[screenNum]; + pGlxScreen = __glXActiveScreens[screenNum]; modes = _gl_context_modes_find_visual( pGlxScreen->modes, visual ); if (modes == NULL) { /* @@ -1339,16 +1375,16 @@ int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc) } if (pDraw) { - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; if (glxc) { - glxPriv = __glXGetDrawablePrivate(pDraw, drawId, glxc->modes); + glxPriv = __glXGetDrawable(glxc, pDraw, drawId); if (glxPriv == NULL) { return __glXBadDrawable; } } else { - glxPriv = __glXFindDrawablePrivate(drawId); + glxPriv = __glXFindDrawable(drawId); if (glxPriv == NULL) { /* This is a window we've never seen before, do nothing */ return Success; @@ -1412,6 +1448,136 @@ int __glXQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc) } +int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; + ClientPtr client = cl->client; + __GLXpixmap *pGlxPixmap; + __GLXcontext *context; + GLXDrawable drawId; + int buffer; + int error; + + pc += __GLX_VENDPRIV_HDR_SIZE; + + drawId = *((CARD32 *) (pc)); + buffer = *((INT32 *) (pc + 4)); + + if (buffer != GLX_FRONT_LEFT_EXT) + return __glXBadPixmap; + + context = __glXForceCurrent (cl, req->contextTag, &error); + if (!context) + return error; + + pGlxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes); + if (!pGlxPixmap) { + client->errorValue = drawId; + return __glXBadPixmap; + } + + if (!context->textureFromPixmap) + return __glXUnsupportedPrivateRequest; + + return context->textureFromPixmap->bindTexImage(context, + buffer, + pGlxPixmap); +} + +int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; + ClientPtr client = cl->client; + __GLXpixmap *pGlxPixmap; + __GLXcontext *context; + GLXDrawable drawId; + int buffer; + int error; + + pc += __GLX_VENDPRIV_HDR_SIZE; + + drawId = *((CARD32 *) (pc)); + buffer = *((INT32 *) (pc + 4)); + + context = __glXForceCurrent (cl, req->contextTag, &error); + if (!context) + return error; + + pGlxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes); + if (!pGlxPixmap) { + client->errorValue = drawId; + return __glXBadDrawable; + } + + if (!context->textureFromPixmap) + return __glXUnsupportedPrivateRequest; + + return context->textureFromPixmap->releaseTexImage(context, + buffer, + pGlxPixmap); +} + +#ifndef GLX_TEXTURE_TARGET_EXT +#define GLX_TEXTURE_TARGET_EXT 0x6001 +#define GLX_TEXTURE_2D_EXT 0x6002 +#define GLX_TEXTURE_RECTANGLE_EXT 0x6003 +#define GLX_NO_TEXTURE_EXT 0x6004 +#define GLX_Y_INVERTED_EXT 0x6006 +#endif + +/* +** Get drawable attributes +*/ +static int +DoGetDrawableAttributes(__GLXclientState *cl, XID drawId) +{ + ClientPtr client = cl->client; + __GLXpixmap *glxPixmap; + xGLXGetDrawableAttributesReply reply; + CARD32 attributes[2]; + int numAttribs; + + glxPixmap = (__GLXpixmap *)LookupIDByType(drawId, __glXPixmapRes); + if (!glxPixmap) { + client->errorValue = drawId; + return __glXBadPixmap; + } + + numAttribs = 2; + reply.length = numAttribs << 1; + reply.type = X_Reply; + reply.sequenceNumber = client->sequence; + reply.numAttribs = numAttribs; + + attributes[0] = GLX_TEXTURE_TARGET_EXT; + attributes[1] = GLX_TEXTURE_RECTANGLE_EXT; + attributes[2] = GLX_Y_INVERTED_EXT; + attributes[3] = GL_FALSE; + + if (client->swapped) { + __glXSwapGetDrawableAttributesReply(client, &reply, attributes); + } else { + WriteToClient(client, sz_xGLXGetDrawableAttributesReply, + (char *)&reply); + WriteToClient(client, reply.length * sizeof (CARD32), + (char *)attributes); + } + + return Success; +} + +int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc; + CARD32 *data; + XID drawable; + + data = (CARD32 *) (req + 1); + drawable = data[0]; + + return DoGetDrawableAttributes(cl, drawable); +} + /************************************************************************/ /* @@ -1985,6 +2151,10 @@ int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc) return Success; case X_GLXvop_BindSwapBarrierSGIX: return __glXBindSwapBarrierSGIX(cl, pc); + case X_GLXvop_BindTexImageEXT: + return __glXBindTexImageEXT(cl, pc); + case X_GLXvop_ReleaseTexImageEXT: + return __glXReleaseTexImageEXT(cl, pc); } #endif @@ -2030,6 +2200,8 @@ int __glXVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc) return __glXCreateContextWithConfigSGIX(cl, pc); case X_GLXvop_CreateGLXPixmapWithConfigSGIX: return __glXCreateGLXPixmapWithConfigSGIX(cl, pc); + case X_GLXvop_GetDrawableAttributesSGIX: + return __glXGetDrawableAttributesSGIX(cl, pc); default: break; } @@ -2064,7 +2236,7 @@ int __glXQueryExtensionsString(__GLXclientState *cl, GLbyte *pc) return BadValue; } - ptr = __glXActiveScreens[screen].GLXextensions; + ptr = __glXActiveScreens[screen]->GLXextensions; n = __glXStrlen(ptr) + 1; length = __GLX_PAD(n) >> 2; @@ -2111,13 +2283,13 @@ int __glXQueryServerString(__GLXclientState *cl, GLbyte *pc) } switch(name) { case GLX_VENDOR: - ptr = __glXActiveScreens[screen].GLXvendor; + ptr = __glXActiveScreens[screen]->GLXvendor; break; case GLX_VERSION: - ptr = __glXActiveScreens[screen].GLXversion; + ptr = __glXActiveScreens[screen]->GLXversion; break; case GLX_EXTENSIONS: - ptr = __glXActiveScreens[screen].GLXextensions; + ptr = __glXActiveScreens[screen]->GLXextensions; break; default: return BadValue; diff --git a/GL/glx/glxcmdsswap.c b/GL/glx/glxcmdsswap.c index 5729cf851..e14106913 100644 --- a/GL/glx/glxcmdsswap.c +++ b/GL/glx/glxcmdsswap.c @@ -40,6 +40,7 @@ #include <dix-config.h> #endif +#include <string.h> #include "glxserver.h" #include "glxutil.h" #include <GL/glxtokens.h> @@ -389,6 +390,64 @@ int __glXSwapQueryContextInfoEXT(__GLXclientState *cl, GLbyte *pc) return __glXQueryContextInfoEXT(cl, pc); } +int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; + GLXDrawable *drawId; + int *buffer; + + __GLX_DECLARE_SWAP_VARIABLES; + + pc += __GLX_VENDPRIV_HDR_SIZE; + + drawId = ((GLXDrawable *) (pc)); + buffer = ((int *) (pc + 4)); + + __GLX_SWAP_SHORT(&req->length); + __GLX_SWAP_INT(&req->contextTag); + __GLX_SWAP_INT(drawId); + __GLX_SWAP_INT(buffer); + + return __glXBindTexImageEXT(cl, (GLbyte *)pc); +} + +int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; + GLXDrawable *drawId; + int *buffer; + + __GLX_DECLARE_SWAP_VARIABLES; + + pc += __GLX_VENDPRIV_HDR_SIZE; + + drawId = ((GLXDrawable *) (pc)); + buffer = ((int *) (pc + 4)); + + __GLX_SWAP_SHORT(&req->length); + __GLX_SWAP_INT(&req->contextTag); + __GLX_SWAP_INT(drawId); + __GLX_SWAP_INT(buffer); + + return __glXReleaseTexImageEXT(cl, (GLbyte *)pc); +} + +int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc) +{ + xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc; + CARD32 *data; + + __GLX_DECLARE_SWAP_VARIABLES; + + data = (CARD32 *) (req + 1); + __GLX_SWAP_SHORT(&req->length); + __GLX_SWAP_INT(&req->contextTag); + __GLX_SWAP_INT(data); + + return __glXGetDrawableAttributesSGIX(cl, (GLbyte *)pc); +} + + /************************************************************************/ /* @@ -463,6 +522,19 @@ void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXT WriteToClient(client, length << 2, (char *)buf); } +void __glXSwapGetDrawableAttributesReply(ClientPtr client, + xGLXGetDrawableAttributesReply *reply, CARD32 *buf) +{ + int length = reply->length; + __GLX_DECLARE_SWAP_VARIABLES; + __GLX_DECLARE_SWAP_ARRAY_VARIABLES; + __GLX_SWAP_SHORT(&reply->sequenceNumber); + __GLX_SWAP_INT(&reply->length); + __GLX_SWAP_INT(&reply->numAttribs); + WriteToClient(client, sz_xGLXQueryContextInfoEXTReply, (char *)reply); + __GLX_SWAP_INT_ARRAY((int *)buf, length); + WriteToClient(client, length << 2, (char *)buf); +} /************************************************************************/ @@ -824,6 +896,10 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc) __GLX_SWAP_INT(pc + 4); CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) ); return Success; + case X_GLXvop_BindTexImageEXT: + return __glXSwapBindTexImageEXT(cl, pc); + case X_GLXvop_ReleaseTexImageEXT: + return __glXSwapReleaseTexImageEXT(cl, pc); } #endif @@ -861,6 +937,8 @@ int __glXSwapVendorPrivateWithReply(__GLXclientState *cl, GLbyte *pc) return __glXSwapCreateContextWithConfigSGIX(cl, pc); case X_GLXvop_CreateGLXPixmapWithConfigSGIX: return __glXSwapCreateGLXPixmapWithConfigSGIX(cl, pc); + case X_GLXvop_GetDrawableAttributesSGIX: + return __glXSwapGetDrawableAttributesSGIX(cl, pc); default: break; } diff --git a/GL/glx/glxcontext.h b/GL/glx/glxcontext.h index 18d8b44c2..5c27aa0b8 100644 --- a/GL/glx/glxcontext.h +++ b/GL/glx/glxcontext.h @@ -41,32 +41,48 @@ ** */ -typedef struct __GLXcontextRec __GLXcontext; - /* XXX: should be defined somewhere globally */ #define CAPI #include "GL/internal/glcore.h" -struct __GLXcontextRec { +typedef struct __GLXtextureFromPixmap __GLXtextureFromPixmap; +struct __GLXtextureFromPixmap { + int (*bindTexImage) (__GLXcontext *baseContext, + int buffer, + __GLXpixmap *pixmap); + int (*releaseTexImage) (__GLXcontext *baseContext, + int buffer, + __GLXpixmap *pixmap); +}; + + +struct __GLXcontext { + void (*destroy) (__GLXcontext *context); + int (*makeCurrent) (__GLXcontext *context); + int (*loseCurrent) (__GLXcontext *context); + int (*copy) (__GLXcontext *dst, + __GLXcontext *src, + unsigned long mask); + int (*forceCurrent) (__GLXcontext *context); + + __GLXdrawable *(*createDrawable)(__GLXcontext *context, + DrawablePtr pDraw, + XID drawId); + + __GLXtextureFromPixmap *textureFromPixmap; + /* ** list of context structs */ - struct __GLXcontextRec *last; - struct __GLXcontextRec *next; + __GLXcontext *last; + __GLXcontext *next; /* ** list of contexts bound to the same drawable */ - struct __GLXcontextRec *nextDrawPriv; - struct __GLXcontextRec *nextReadPriv; - - /* - ** Opaque pointer the context object created by the GL that the - ** server is bound with. Never dereferenced by this code, but used - ** as a handle to feed to the routines in the screen info struct. - */ - __GLinterface *gc; + __GLXcontext *nextDrawPriv; + __GLXcontext *nextReadPriv; /* ** mode struct for this context @@ -78,7 +94,7 @@ struct __GLXcontextRec { ** when the context is created. */ ScreenPtr pScreen; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; /* ** This context is created with respect to this visual. @@ -152,8 +168,8 @@ struct __GLXcontextRec { /* ** The drawable private this context is bound to */ - __GLXdrawablePrivate *drawPriv; - __GLXdrawablePrivate *readPriv; + __GLXdrawable *drawPriv; + __GLXdrawable *readPriv; }; /* pending state defines */ diff --git a/GL/glx/glxdrawable.h b/GL/glx/glxdrawable.h index 38a05bfeb..2d5d07a79 100644 --- a/GL/glx/glxdrawable.h +++ b/GL/glx/glxdrawable.h @@ -45,19 +45,23 @@ typedef struct { DrawablePtr pDraw; __GLcontextModes *modes; - __GLXscreenInfo *pGlxScreen; + __GLXscreen *pGlxScreen; ScreenPtr pScreen; Bool idExists; int refcnt; } __GLXpixmap; -struct __GLXdrawablePrivateRec { +struct __GLXdrawable { + void (*destroy)(__GLXdrawable *private); + GLboolean (*resize)(__GLXdrawable *private); + GLboolean (*swapBuffers)(__GLXdrawable *); + /* ** list of drawable private structs */ - struct __GLXdrawablePrivateRec *last; - struct __GLXdrawablePrivateRec *next; + __GLXdrawable *last; + __GLXdrawable *next; DrawablePtr pDraw; XID drawId; @@ -76,32 +80,13 @@ struct __GLXdrawablePrivateRec { __GLcontextModes *modes; /* - ** cached drawable size and origin - */ - - GLint xorigin, yorigin; - GLint width, height; - - /* ** Lists of contexts bound to this drawable. There are two lists here. ** One list is of the contexts that have this drawable bound for drawing, ** and the other is the list of contexts that have this drawable bound ** for reading. */ - struct __GLXcontextRec *drawGlxc; - struct __GLXcontextRec *readGlxc; - - /* - ** "methods" that the drawble should be able to respond to. - */ - void (*freeBuffers)(struct __GLXdrawablePrivateRec *); - void (*updatePalette)(struct __GLXdrawablePrivateRec *); - GLboolean (*swapBuffers)(struct __GLXdrawablePrivateRec *); - - /* - ** The GL drawable (information shared between GLX and the GL core) - */ - __GLdrawablePrivate glPriv; + __GLXcontext *drawGlxc; + __GLXcontext *readGlxc; /* ** reference count diff --git a/GL/glx/glxdri.c b/GL/glx/glxdri.c new file mode 100644 index 000000000..a78af1b06 --- /dev/null +++ b/GL/glx/glxdri.c @@ -0,0 +1,926 @@ +/* + * Copyright © 2006 Red Hat, Inc + * + * Permission to use, copy, modify, distribute, and sell this software + * and its documentation for any purpose is hereby granted without + * fee, provided that the above copyright notice appear in all copies + * and that both that copyright notice and this permission notice + * appear in supporting documentation, and that the name of Red Hat, + * Inc not be used in advertising or publicity pertaining to + * distribution of the software without specific, written prior + * permission. Red Hat, Inc makes no representations about the + * suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * RED HAT, INC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN + * NO EVENT SHALL RED HAT, INC BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS + * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, + * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <sys/time.h> +#include <dlfcn.h> + +#include <drm.h> +#include <GL/gl.h> +#include <GL/internal/dri_interface.h> + +#include <windowstr.h> +#include <os.h> + +#define _XF86DRI_SERVER_ +#include <drm_sarea.h> +#include <xf86drm.h> +#include <xf86dristr.h> +#include <xf86str.h> +#include <xf86.h> +#include <dri.h> + +#define DRI_NEW_INTERFACE_ONLY +#include "glxserver.h" +#include "glxutil.h" +#include "glcontextmodes.h" + +#include "g_disptab.h" +#include "g_disptab_EXT.h" +#include "glapitable.h" +#include "glapi.h" +#include "glthread.h" +#include "dispatch.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 __GLXDRIdrawable __GLXDRIdrawable; + +struct __GLXDRIscreen { + __GLXscreen base; + + __DRIscreen driScreen; + void *driver; +}; + +struct __GLXDRIcontext { + __GLXcontext base; + + __DRIcontext driContext; +}; + +struct __GLXDRIdrawable { + __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. + */ +#define INTERNAL_VERSION 20050727 + +static const char CREATE_NEW_SCREEN_FUNC[] = + "__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION); + +static void +__glXDRIleaveServer(void) +{ + int i; + + for (i = 0; i < screenInfo.numScreens; i++) + DRIDoBlockHandler(i, NULL, NULL, NULL); +} + +static void +__glXDRIenterServer(void) +{ + int i; + + for (i = 0; i < screenInfo.numScreens; i++) + DRIDoWakeupHandler(i, NULL, 0, NULL); +} + +static void +__glXDRIdrawableDestroy(__GLXdrawable *private) +{ +#if 0 + (*glxPriv->driDrawable.destroyDrawable)(NULL, + glxPriv->driDrawable.private); +#endif + + __glXFree(private); +} + +static GLboolean +__glXDRIdrawableResize(__GLXdrawable *glxPriv) +{ + /* Nothing to do here, the DRI driver asks the server for drawable + * geometry when it sess the SAREA timestamps change.*/ + + return GL_TRUE; +} + +static GLboolean +__glXDRIdrawableSwapBuffers(__GLXdrawable *basePrivate) +{ + __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate; + __GLXDRIscreen *screen; + + /* FIXME: We're jumping through hoops here to get the DRIdrawable + * which the dri driver tries to keep to it self... cf. FIXME in + * createDrawable. */ + + screen = (__GLXDRIscreen *) __glXgetActiveScreen(private->base.pDraw->pScreen->myNum); + private->driDrawable = (screen->driScreen.getDrawable)(NULL, + private->base.drawId, + screen->driScreen.private); + + (*private->driDrawable->swapBuffers)(NULL, + private->driDrawable->private); + + return TRUE; +} + +static __GLXdrawable * +__glXDRIcontextCreateDrawable(__GLXcontext *context, + DrawablePtr pDraw, + XID drawId) +{ + __GLXDRIdrawable *private; + + private = __glXMalloc(sizeof *private); + if (private == NULL) + return NULL; + + memset(private, 0, sizeof *private); + + if (!__glXDrawableInit(&private->base, context, pDraw, drawId)) { + __glXFree(private); + return NULL; + } + + private->base.destroy = __glXDRIdrawableDestroy; + private->base.resize = __glXDRIdrawableResize; + private->base.swapBuffers = __glXDRIdrawableSwapBuffers; + +#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.*/ + + /* The last argument is 'attrs', which is used with pbuffers which + * we currently don't support. */ + + glxPriv->driDrawable.private = + (pGlxScreen->driScreen.createNewDrawable)(NULL, modes, + drawId, + &glxPriv->driDrawable, + 0, + NULL); +#endif + + return &private->base; +} + + +static void +__glXDRIcontextDestroy(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + context->driContext.destroyContext(NULL, + context->base.pScreen->myNum, + context->driContext.private); + __glXFree(context); +} + +static int +__glXDRIcontextMakeCurrent(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + return (*context->driContext.bindContext)(NULL, + context->base.pScreen->myNum, + baseContext->drawPriv->drawId, + baseContext->readPriv->drawId, + &context->driContext); +} + +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); +} + +static int +__glXDRIcontextCopy(__GLXcontext *baseDst, __GLXcontext *baseSrc, + unsigned long mask) +{ + __GLXDRIcontext *dst = (__GLXDRIcontext *) baseDst; + __GLXDRIcontext *src = (__GLXDRIcontext *) baseSrc; + + /* FIXME: We will need to add DRIcontext::copyContext for this. */ + + (void) dst; + (void) src; + + return FALSE; +} + +static int +__glXDRIcontextForceCurrent(__GLXcontext *baseContext) +{ + __GLXDRIcontext *context = (__GLXDRIcontext *) baseContext; + + return (*context->driContext.bindContext)(NULL, + context->base.pScreen->myNum, + baseContext->drawPriv->drawId, + baseContext->readPriv->drawId, + &context->driContext); +} + +static int +glxCountBits(int word) +{ + int ret = 0; + + while (word) { + ret += (word & 1); + word >>= 1; + } + + return ret; +} + +static void +glxFillAlphaChannel (PixmapPtr pixmap) +{ + int i, j; + CARD32 *pixels = (CARD32 *)pixmap->devPrivate.ptr; + CARD32 rowstride = pixmap->devKind / 4; + CARD32 x, y; + + x = pixmap->drawable.x; + y = pixmap->drawable.y; + + for (i = y; i < pixmap->drawable.height + y; ++i) + { + for (j = x; j < pixmap->drawable.width + x; ++j) + { + int index = i * rowstride + j; + + pixels[index] |= 0xFF000000; + } + } +} + +/* + * (sticking this here for lack of a better place) + * Known issues with the GLX_EXT_texture_from_pixmap implementation: + * - In general we ignore the fbconfig, lots of examples follow + * - No fbconfig handling for multiple mipmap levels + * - No fbconfig handling for 1D textures + * - No fbconfig handling for TEXTURE_TARGET + * - No fbconfig exposure of Y inversion state + * - No GenerateMipmapEXT support (due to no FBO support) + * - No damage tracking between binds + * - No support for anything but 16bpp and 32bpp-sparse pixmaps + */ + +static int +__glXDRIbindTexImage(__GLXcontext *baseContext, + int buffer, + __GLXpixmap *glxPixmap) +{ + PixmapPtr pixmap; + int bpp; + Bool npot; + + pixmap = (PixmapPtr) glxPixmap->pDraw; + bpp = pixmap->drawable.depth >= 24 ? 4 : 2; /* XXX 24bpp packed, 8, etc */ + + CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, + pixmap->devKind / bpp) ); + CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, + pixmap->drawable.y) ); + CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, + pixmap->drawable.x) ); + + if (pixmap->drawable.depth == 24) + glxFillAlphaChannel(pixmap); + + npot = !(glxCountBits(pixmap->drawable.width) == 1 && + glxCountBits(pixmap->drawable.height) == 1) /* || + strstr(CALL_GetString(GL_EXTENSIONS, + "GL_ARB_texture_non_power_of_two")) */ ; + + CALL_TexImage2D( GET_DISPATCH(), + ( npot ? GL_TEXTURE_RECTANGLE_ARB : GL_TEXTURE_2D, + 0, + bpp == 4 ? 4 : 3, + pixmap->drawable.width, + pixmap->drawable.height, + 0, + bpp == 4 ? GL_BGRA : GL_RGB, + bpp == 4 ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT_5_6_5, + pixmap->devPrivate.ptr ) ); + + return Success; +} + +static int +__glXDRIreleaseTexImage(__GLXcontext *baseContext, + int buffer, + __GLXpixmap *pixmap) +{ + return Success; +} + +static __GLXtextureFromPixmap __glXDRItextureFromPixmap = { + __glXDRIbindTexImage, + __glXDRIreleaseTexImage +}; + +static void +__glXDRIscreenDestroy(__GLXscreen *baseScreen) +{ + __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen; + + screen->driScreen.destroyScreen(NULL, + screen->base.pScreen->myNum, + screen->driScreen.private); + + dlclose(screen->driver); + + __glXScreenDestroy(baseScreen); + + __glXFree(screen); +} + +static __GLXcontext * +__glXDRIscreenCreateContext(__GLXscreen *baseScreen, + __GLcontextModes *modes, + __GLXcontext *baseShareContext) +{ + __GLXDRIscreen *screen = (__GLXDRIscreen *) baseScreen; + __GLXDRIcontext *context, *shareContext; + void *sharePrivate; + + shareContext = (__GLXDRIcontext *) baseShareContext; + if (shareContext) + sharePrivate = shareContext->driContext.private; + else + sharePrivate = NULL; + + context = __glXMalloc(sizeof *context); + if (context == NULL) + return NULL; + + memset(context, 0, sizeof *context); + context->base.destroy = __glXDRIcontextDestroy; + context->base.makeCurrent = __glXDRIcontextMakeCurrent; + context->base.loseCurrent = __glXDRIcontextLoseCurrent; + context->base.copy = __glXDRIcontextCopy; + context->base.forceCurrent = __glXDRIcontextForceCurrent; + context->base.createDrawable = __glXDRIcontextCreateDrawable; + + context->base.textureFromPixmap = &__glXDRItextureFromPixmap; + + context->driContext.private = + screen->driScreen.createNewContext(NULL, modes, + 0, /* render type */ + sharePrivate, + &context->driContext); + + context->driContext.mode = modes; + + return &context->base; +} + +static unsigned +filter_modes(__GLcontextModes **server_modes, + const __GLcontextModes *driver_modes) +{ + __GLcontextModes * m; + __GLcontextModes ** prev_next; + const __GLcontextModes * check; + unsigned modes_count = 0; + + if ( driver_modes == NULL ) { + LogMessage(X_WARNING, + "AIGLX: 3D driver returned no fbconfigs.\n"); + return 0; + } + + /* For each mode in server_modes, check to see if a matching mode exists + * in driver_modes. If not, then the mode is not available. + */ + + prev_next = server_modes; + for ( m = *prev_next ; m != NULL ; m = *prev_next ) { + GLboolean do_delete = GL_TRUE; + + for ( check = driver_modes ; check != NULL ; check = check->next ) { + if ( _gl_context_modes_are_same( m, check ) ) { + do_delete = GL_FALSE; + break; + } + } + + /* The 3D has to support all the modes that match the GLX visuals + * sent from the X server. + */ + if ( do_delete && (m->visualID != 0) ) { + do_delete = GL_FALSE; + + LogMessage(X_WARNING, + "AIGLX: 3D driver claims to not support " + "visual 0x%02x\n", m->visualID); + } + + if ( do_delete ) { + *prev_next = m->next; + + m->next = NULL; + _gl_context_modes_destroy( m ); + } + else { + modes_count++; + prev_next = & m->next; + } + } + + return modes_count; +} + + +static __DRIfuncPtr getProcAddress(const char *proc_name) +{ + return NULL; +} + +static __DRIscreen *findScreen(__DRInativeDisplay *dpy, int scrn) +{ + __GLXDRIscreen *screen = + (__GLXDRIscreen *) __glXgetActiveScreen(scrn); + + return &screen->driScreen; +} + +static GLboolean windowExists(__DRInativeDisplay *dpy, __DRIid draw) +{ + WindowPtr pWin = (WindowPtr) LookupIDByType(draw, RT_WINDOW); + + return pWin == NULL ? GL_FALSE : GL_TRUE; +} + +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(); + retval = DRICreateContext(pScreen, visual, fakeID, hw_context); + __glXDRIleaveServer(); + return retval; +} + +static GLboolean destroyContext(__DRInativeDisplay *dpy, int screen, + __DRIid context) +{ + GLboolean retval; + + __glXDRIenterServer(); + retval = DRIDestroyContext(screenInfo.screens[screen], context); + __glXDRIleaveServer(); + 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(); + retval = DRICreateDrawable(screenInfo.screens[screen], + drawable, + pDrawable, + hHWDrawable); + __glXDRIleaveServer(); + return retval; +} + +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(); + retval = DRIDestroyDrawable(screenInfo.screens[screen], + drawable, + pDrawable); + __glXDRIleaveServer(); + return retval; +} + +static GLboolean +getDrawableInfo(__DRInativeDisplay *dpy, int screen, + __DRIid drawable, 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; + 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(); + retval = DRIGetDrawableInfo(screenInfo.screens[screen], + pDrawable, index, stamp, + x, y, width, height, + numClipRects, &pClipRects, + backX, backY, + numBackClipRects, &pBackClipRects); + __glXDRIleaveServer(); + + if (*numClipRects > 0) { + size = sizeof (drm_clip_rect_t) * *numClipRects; + *ppClipRects = __glXMalloc (size); + if (*ppClipRects != NULL) + memcpy (*ppClipRects, pClipRects, size); + } + else { + *ppClipRects = NULL; + } + + if (*numBackClipRects > 0) { + size = sizeof (drm_clip_rect_t) * *numBackClipRects; + *ppBackClipRects = __glXMalloc (size); + if (*ppBackClipRects != NULL) + memcpy (*ppBackClipRects, pBackClipRects, size); + } + else { + *ppBackClipRects = NULL; + } + + return GL_TRUE; +} + +static int +getUST(int64_t *ust) +{ + struct timeval tv; + + if (ust == NULL) + return -EFAULT; + + if (gettimeofday(&tv, NULL) == 0) { + ust[0] = (tv.tv_sec * 1000000) + tv.tv_usec; + return 0; + } else { + return -errno; + } +} + +/* 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, + NULL, /* glXGetMscRateOML, */ +}; + +static const char dri_driver_path[] = DRI_DRIVER_PATH; + +static __GLXscreen * +__glXDRIscreenProbe(ScreenPtr pScreen) +{ + PFNCREATENEWSCREENFUNC createNewScreen; + drm_handle_t hSAREA; + drmAddress pSAREA = NULL; + char *BusID; + __DRIversion ddx_version; + __DRIversion dri_version; + __DRIversion drm_version; + __DRIframebuffer framebuffer; + int fd = -1; + int status; + const char *err_msg; + const char *err_extra = NULL; + int api_ver = INTERNAL_VERSION; + drm_magic_t magic; + drmVersionPtr version; + char *driverName; + drm_handle_t hFB; + int junk; + __GLcontextModes * driver_modes; + __GLXDRIscreen *screen; + void *dev_priv = NULL; + char filename[128]; + + screen = __glXMalloc(sizeof *screen); + if (screen == NULL) + return NULL; + memset(screen, 0, sizeof *screen); + + screen->base.destroy = __glXDRIscreenDestroy; + screen->base.createContext = __glXDRIscreenCreateContext; + screen->base.pScreen = pScreen; + + /* DRI protocol version. */ + dri_version.major = XF86DRI_MAJOR_VERSION; + dri_version.minor = XF86DRI_MINOR_VERSION; + dri_version.patch = XF86DRI_PATCH_VERSION; + + framebuffer.base = NULL; + framebuffer.dev_priv = NULL; + + if (!DRIOpenConnection(pScreen, &hSAREA, &BusID)) { + err_msg = "DRIOpenConnection"; + err_extra = NULL; + goto handle_error; + } + + fd = drmOpen(NULL, BusID); + + if (fd < 0) { + err_msg = "open DRM"; + err_extra = strerror( -fd ); + goto handle_error; + } + + if (drmGetMagic(fd, &magic)) { + err_msg = "drmGetMagic"; + goto handle_error; + } + + version = drmGetVersion(fd); + if (version) { + drm_version.major = version->version_major; + drm_version.minor = version->version_minor; + drm_version.patch = version->version_patchlevel; + drmFreeVersion(version); + } + else { + drm_version.major = -1; + drm_version.minor = -1; + drm_version.patch = -1; + } + + if (!DRIAuthConnection(pScreen, magic)) { + err_msg = "DRIAuthConnection"; + goto handle_error; + } + + /* Get device name (like "tdfx") and the ddx version numbers. + * We'll check the version in each DRI driver's "createNewScreen" + * function. */ + if (!DRIGetClientDriverName(pScreen, + &ddx_version.major, + &ddx_version.minor, + &ddx_version.patch, + &driverName)) { + err_msg = "DRIGetClientDriverName"; + goto handle_error; + } + + snprintf(filename, sizeof filename, "%s/%s_dri.so", + dri_driver_path, driverName); + + screen->driver = dlopen(filename, RTLD_LAZY | RTLD_LOCAL); + if (screen->driver == NULL) { + err_msg = "Loading driver"; + err_extra = filename; + goto handle_error; + } + + createNewScreen = dlsym(screen->driver, CREATE_NEW_SCREEN_FUNC); + if (createNewScreen == NULL) { + err_msg = "Driver entry point lookup"; + err_extra = CREATE_NEW_SCREEN_FUNC; + goto handle_error; + } + + /* + * Get device-specific info. pDevPriv will point to a struct + * (such as DRIRADEONRec in xfree86/driver/ati/radeon_dri.h) that + * has information about the screen size, depth, pitch, ancilliary + * buffers, DRM mmap handles, etc. + */ + if (!DRIGetDeviceInfo(pScreen, &hFB, &junk, + &framebuffer.size, &framebuffer.stride, + &framebuffer.dev_priv_size, &framebuffer.dev_priv)) { + err_msg = "XF86DRIGetDeviceInfo"; + goto handle_error; + } + + /* Sigh... the DRI interface is broken; the DRI driver will free + * the dev private pointer using _mesa_free() on screen destroy, + * but we can't use _mesa_malloc() here. In fact, the DRI driver + * shouldn't free data it didn't allocate itself, but what can you + * do... */ + dev_priv = __glXMalloc(framebuffer.dev_priv_size); + if (dev_priv == NULL) { + err_msg = "dev_priv allocation"; + goto handle_error; + } + memcpy(dev_priv, framebuffer.dev_priv, framebuffer.dev_priv_size); + framebuffer.dev_priv = dev_priv; + + framebuffer.width = pScreen->width; + framebuffer.height = pScreen->height; + + /* Map the framebuffer region. */ + status = drmMap(fd, hFB, framebuffer.size, + (drmAddressPtr)&framebuffer.base); + if (status != 0) { + err_msg = "drmMap of framebuffer"; + err_extra = strerror( -status ); + goto handle_error; + } + + /* Map the SAREA region. Further mmap regions may be setup in + * each DRI driver's "createNewScreen" function. + */ + status = drmMap(fd, hSAREA, SAREA_MAX, &pSAREA); + if (status != 0) { + err_msg = "drmMap of sarea"; + err_extra = strerror( -status ); + goto handle_error; + } + + driver_modes = NULL; + screen->driScreen.private = + (*createNewScreen)(NULL, pScreen->myNum, + &screen->driScreen, + screen->base.modes, + &ddx_version, + &dri_version, + &drm_version, + &framebuffer, + pSAREA, + fd, + api_ver, + &interface_methods, + &driver_modes); + + if (screen->driScreen.private == NULL) { + err_msg = "InitDriver"; + err_extra = NULL; + goto handle_error; + } + + __glXScreenInit(&screen->base, pScreen); + + filter_modes(&screen->base.modes, driver_modes); + _gl_context_modes_destroy(driver_modes); + + __glXsetEnterLeaveServerFuncs(__glXDRIenterServer, __glXDRIleaveServer); + + LogMessage(X_INFO, + "AIGLX: Loaded and initialized %s\n", filename); + + return &screen->base; + + handle_error: + if (pSAREA != NULL) + drmUnmap(pSAREA, SAREA_MAX); + + if (framebuffer.base != NULL) + drmUnmap((drmAddress)framebuffer.base, framebuffer.size); + + if (dev_priv != NULL) + __glXFree(dev_priv); + + if (fd >= 0) + drmClose(fd); + + DRICloseConnection(pScreen); + + if (screen->driver) + dlclose(screen->driver); + + xfree(screen); + + if (err_extra != NULL) + LogMessage(X_ERROR, + "AIGLX error: %s failed (%s)\n", err_msg, err_extra); + else + LogMessage(X_ERROR, "AIGLX error: %s failed\n", err_msg); + + ErrorF("GLX-DRI: reverting to software rendering\n"); + + return NULL; +} + +__GLXprovider __glXDRIProvider = { + __glXDRIscreenProbe, + "DRI", + NULL +}; diff --git a/GL/glx/glxext.c b/GL/glx/glxext.c index fa1382983..e4ad47803 100644 --- a/GL/glx/glxext.c +++ b/GL/glx/glxext.c @@ -23,6 +23,7 @@ #include <dix-config.h> #endif +#include <string.h> #include "glxserver.h" #include <windowstr.h> #include <propertyst.h> @@ -31,19 +32,12 @@ #include "unpack.h" #include "glxutil.h" #include "glxext.h" -#include "micmap.h" - -void GlxWrapInitVisuals(miInitVisualsProcPtr *); -void GlxSetVisualConfigs(int nconfigs, - __GLXvisualConfig *configs, void **privates); - -static __GLXextensionInfo *__glXExt /* = &__glDDXExtensionInfo */; +static Bool inDispatch; /* ** Forward declarations. */ -static int __glXSwapDispatch(ClientPtr); static int __glXDispatch(ClientPtr); /* @@ -52,8 +46,7 @@ static int __glXDispatch(ClientPtr); static void ResetExtension(ExtensionEntry* extEntry) { __glXFlushContextCache(); - (*__glXExt->resetExtension)(); - __glXScreenReset(); + __glXResetScreens(); } /* @@ -159,24 +152,64 @@ static int PixmapGone(__GLXpixmap *pGlxPixmap, XID id) } /* +** Destroy routine that gets called when a drawable is freed. A drawable +** contains the ancillary buffers needed for rendering. +*/ +static Bool DrawableGone(__GLXdrawable *glxPriv, XID xid) +{ + __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. + */ + 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->readGlxc; cx; cx = cx1) { + cx1 = cx->nextReadPriv; + cx->pendingState |= __GLX_PENDING_DESTROY; + } + } + + __glXUnrefDrawable(glxPriv); + + return True; +} + +/* ** Free a context. */ GLboolean __glXFreeContext(__GLXcontext *cx) { if (cx->idExists || cx->isCurrent) return GL_FALSE; - if (!cx->isDirect) { - if ((*cx->gc->exports.destroyContext)((__GLcontext *)cx->gc) == GL_FALSE) { - return GL_FALSE; - } - } if (cx->feedbackBuf) __glXFree(cx->feedbackBuf); if (cx->selectBuf) __glXFree(cx->selectBuf); - __glXFree(cx); if (cx == __glXLastContext) { __glXFlushContextCache(); } + /* We can get here through both regular dispatching from + * __glXDispatch() or as a callback from the resource manager. In + * the latter case we need to lift the DRI lock manually. */ + + if (!inDispatch) + __glXleaveServer(); + + cx->destroy(cx); + + if (!inDispatch) + __glXenterServer(); + return GL_TRUE; } @@ -240,13 +273,14 @@ void GlxExtensionInit(void) __glXContextRes = CreateNewResourceType((DeleteType)ContextGone); __glXClientRes = CreateNewResourceType((DeleteType)ClientGone); __glXPixmapRes = CreateNewResourceType((DeleteType)PixmapGone); + __glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone); /* ** Add extension to server extensions. */ extEntry = AddExtension(GLX_EXTENSION_NAME, __GLX_NUMBER_EVENTS, __GLX_NUMBER_ERRORS, __glXDispatch, - __glXSwapDispatch, ResetExtension, + __glXDispatch, ResetExtension, StandardMinorOpcode); if (!extEntry) { FatalError("__glXExtensionInit: AddExtensions failed\n"); @@ -280,53 +314,7 @@ void GlxExtensionInit(void) /* ** Initialize screen specific data. */ - __glXScreenInit(screenInfo.numScreens); -} - -/************************************************************************/ - -Bool __glXCoreType(void) -{ - return __glXExt->type; -} - -/************************************************************************/ - -void GlxSetVisualConfigs(int nconfigs, - __GLXvisualConfig *configs, void **privates) -{ - (*__glXExt->setVisualConfigs)(nconfigs, configs, privates); -} - -static miInitVisualsProcPtr saveInitVisualsProc; - -Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp, - int *nvisualp, int *ndepthp, - int *rootDepthp, VisualID *defaultVisp, - unsigned long sizes, int bitsPerRGB, - int preferredVis) -{ - Bool ret; - - if (saveInitVisualsProc) { - ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp, - rootDepthp, defaultVisp, sizes, bitsPerRGB, - preferredVis); - if (!ret) - return False; - } - (*__glXExt->initVisuals)(visualp, depthp, nvisualp, ndepthp, rootDepthp, - defaultVisp, sizes, bitsPerRGB); - return True; -} - -void -GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc) -{ - saveInitVisualsProc = *initVisProc; - *initVisProc = GlxInitVisuals; - /* HACK: this shouldn't be done here but it's the earliest time */ - __glXExt = __glXglDDXExtensionInfo(); /* from GLcore */ + __glXInitScreens(); } /************************************************************************/ @@ -377,7 +365,7 @@ __GLXcontext *__glXForceCurrent(__GLXclientState *cl, GLXContextTag tag, /* Make this context the current one for the GL. */ if (!cx->isDirect) { - if (!(*cx->gc->exports.forceCurrent)((__GLcontext *)cx->gc)) { + if (!(*cx->forceCurrent)(cx)) { /* Bind failed, and set the error code. Bummer */ cl->client->errorValue = cx->id; *error = __glXBadContextState; @@ -393,12 +381,51 @@ __GLXcontext *__glXForceCurrent(__GLXclientState *cl, GLXContextTag tag, /* ** Top level dispatcher; all commands are executed from here down. */ + +/* I cried when I wrote this. Damn you XAA! */ + +static void +__glXnopEnterServer(void) +{ +} + +static void +__glXnopLeaveServer(void) +{ +} + +static void (*__glXenterServerFunc)(void) = __glXnopEnterServer; +static void (*__glXleaveServerFunc)(void) = __glXnopLeaveServer; + +void __glXsetEnterLeaveServerFuncs(void (*enter)(void), + void (*leave)(void)) +{ + __glXenterServerFunc = enter; + __glXleaveServerFunc = leave; +} + + +void __glXenterServer(void) +{ + (*__glXenterServerFunc)(); +} + +void __glXleaveServer(void) +{ + (*__glXleaveServerFunc)(); +} + + +/* +** Top level dispatcher; all commands are executed from here down. +*/ static int __glXDispatch(ClientPtr client) { REQUEST(xGLXSingleReq); CARD8 opcode; int (*proc)(__GLXclientState *cl, GLbyte *pc); __GLXclientState *cl; + int retval; opcode = stuff->glxCode; cl = __glXClients[client->index]; @@ -443,54 +470,22 @@ static int __glXDispatch(ClientPtr client) /* ** Use the opcode to index into the procedure table. */ - proc = __glXSingleTable[opcode]; - return (*proc)(cl, (GLbyte *) stuff); -} + if (client->swapped) + proc = __glXSwapSingleTable[opcode]; + else + proc = __glXSingleTable[opcode]; -static int __glXSwapDispatch(ClientPtr client) -{ - REQUEST(xGLXSingleReq); - CARD8 opcode; - int (*proc)(__GLXclientState *cl, GLbyte *pc); - __GLXclientState *cl; + __glXleaveServer(); - opcode = stuff->glxCode; - cl = __glXClients[client->index]; - if (!cl) { - cl = (__GLXclientState *) __glXMalloc(sizeof(__GLXclientState)); - __glXClients[client->index] = cl; - if (!cl) { - return BadAlloc; - } - __glXMemset(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; - } + inDispatch = True; - /* - ** Check for valid opcode. - */ - if (opcode >= __GLX_SINGLE_TABLE_SIZE) { - return BadRequest; - } + retval = proc(cl, (GLbyte *) stuff); - /* - ** Use the opcode to index into the procedure table. - */ - proc = __glXSwapSingleTable[opcode]; - return (*proc)(cl, (GLbyte *) stuff); + inDispatch = False; + + __glXenterServer(); + + return retval; } int __glXNoSuchSingleOpcode(__GLXclientState *cl, GLbyte *pc) diff --git a/GL/glx/glxfb.c b/GL/glx/glxfb.c deleted file mode 100644 index 0d433d25d..000000000 --- a/GL/glx/glxfb.c +++ /dev/null @@ -1,183 +0,0 @@ -/* $XFree86$ */ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -/* -** An implementation of a buffer which is part of the front buffer -*/ - -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#include "glxserver.h" -#include "glxutil.h" -#include "glxfb.h" - -#include <gcstruct.h> - -/* so we don't include glmath.h */ -extern GLuint __glFloorLog2(GLuint); - -typedef struct __GLFBbufferInfoRec { - GCPtr pGC; -} __GLFBbufferInfo; - -extern PixmapPtr __glXPrivPixGetPtr(__GLdrawableBuffer *); - -/* ---------------------------------------------------------- */ - -static GLboolean -Resize(__GLdrawableBuffer *buf, - GLint x, GLint y, GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, GLuint bufferMask) -{ - buf->width = width; - buf->height = height; - buf->byteWidth = width * buf->elementSize; - buf->outerWidth = width; - - return GL_TRUE; -} - -static void -Lock(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ -} - -static void -Unlock(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ -} - -/* -** Do a swap buffer with -** a memory surface as a back buffer -** a FB surface as a front buffer -*/ -GLboolean -__glXFBMemSwapBuffers(__GLXdrawablePrivate *glxPriv) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - __GLdrawableBuffer *front = &glPriv->frontBuffer; - __GLdrawableBuffer *back = &glPriv->backBuffer; - __GLFBbufferInfo *bufferInfo; - GCPtr pGC; - GLint width, height, depth, pad; - GLubyte *buf; - - bufferInfo = (__GLFBbufferInfo *) front->other; - pGC = bufferInfo->pGC; - - width = back->width; - height = back->height; - depth = back->depth; - buf = back->base; - pad = back->outerWidth - back->width; /* back buffer padding */ - /* adjust buffer padding. X wants left, GL has right */ - buf -= pad; - - ValidateGC(glxPriv->pDraw, pGC); - (*pGC->ops->PutImage)(glxPriv->pDraw, pGC, - depth, - 0, 0, width, height, - pad, ZPixmap, - (char *)buf); - - return GL_TRUE; -} - -static void -Free(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ - __GLFBbufferInfo *bufferInfo; - - bufferInfo = (__GLFBbufferInfo *) buf->other; - - if (bufferInfo->pGC) { - FreeScratchGC(bufferInfo->pGC); - } - - __glXFree(bufferInfo); - buf->other = NULL; -} - -/* -** function to return the X GC of this buffer (to be used by DDX) -*/ -GCPtr __glXFBGetGC(__GLdrawableBuffer *buf) -{ - __GLFBbufferInfo *bufferInfo; - - bufferInfo = (__GLFBbufferInfo *) buf->other; - - if (bufferInfo) { - return bufferInfo->pGC; - } else { - return NULL; - } -} - - -void -__glXInitFB(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, GLint bits) -{ - __GLFBbufferInfo *bufferInfo; - __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *) glPriv->other; - GCPtr pGC; - - buf->depth = bits; - buf->width = buf->height = 0; /* to be filled during Update */ - buf->handle = buf->base = NULL; /* to be filled during Update */ - buf->size = 0; - buf->byteWidth = 0; - buf->elementSize = ((bits-1) / 8) + 1; - buf->elementSizeLog2 = __glFloorLog2(buf->elementSize); - - buf->resize = Resize; - buf->lock = Lock; - buf->unlock = Unlock; - buf->fill = NULL; - buf->free = Free; - - /* allocate local information */ - bufferInfo = (__GLFBbufferInfo *) __glXMalloc(sizeof(__GLFBbufferInfo)); - buf->other = (void *) bufferInfo; - - pGC = CreateScratchGC(glxPriv->pDraw->pScreen, - glxPriv->pDraw->depth); - bufferInfo->pGC = pGC; - (*pGC->funcs->ChangeClip)(pGC, CT_NONE, NULL, 0); -} diff --git a/GL/glx/glxfb.h b/GL/glx/glxfb.h deleted file mode 100644 index 325146d43..000000000 --- a/GL/glx/glxfb.h +++ /dev/null @@ -1,52 +0,0 @@ -/* $XFree86$ */ -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#ifndef _glxfb_h_ -#define _glxfb_h_ - -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -extern void __glXInitFB(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, - GLint bits); - -extern GCPtr __glXFBGetGC(__GLdrawableBuffer *buf); - -extern GLboolean __glXFBMemSwapBuffers(__GLXdrawablePrivate *glxPriv); - -#endif /* _glxfb_h_ */ - diff --git a/GL/glx/glximports.c b/GL/glx/glximports.c deleted file mode 100644 index a443495c4..000000000 --- a/GL/glx/glximports.c +++ /dev/null @@ -1,188 +0,0 @@ -/* $XFree86: xc/programs/Xserver/GL/glx/glximports.c,v 1.5 2001/03/21 16:29:36 dawes Exp $ */ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> - -#include "glxserver.h" -#include "glxcontext.h" -#include "glximports.h" -#include "GL/glx_ansic.h" - -void *__glXImpMalloc(__GLcontext *gc, size_t size) -{ - void *addr; - - if (size == 0) { - return NULL; - } - addr = xalloc(size); - if (addr == NULL) { - /* XXX: handle out of memory error */ - return NULL; - } - return addr; -} - -void *__glXImpCalloc(__GLcontext *gc, size_t numElements, size_t elementSize) -{ - void *addr; - size_t size; - - if ((numElements == 0) || (elementSize == 0)) { - return NULL; - } - size = numElements * elementSize; - addr = xalloc(size); - if (addr == NULL) { - /* XXX: handle out of memory error */ - return NULL; - } - /* zero out memory */ - __glXMemset(addr, 0, size); - - return addr; -} - -void __glXImpFree(__GLcontext *gc, void *addr) -{ - if (addr) { - xfree(addr); - } -} - -void *__glXImpRealloc(__GLcontext *gc, void *addr, size_t newSize) -{ - void *newAddr; - - if (addr) { - if (newSize == 0) { - xfree(addr); - return NULL; - } - newAddr = xrealloc(addr, newSize); - } else { - if (newSize == 0) { - return NULL; - } - newAddr = xalloc(newSize); - } - if (newAddr == NULL) { - return NULL; /* XXX: out of memory error */ - } - - return newAddr; -} - -void __glXImpWarning(__GLcontext *gc, char *msg) -{ - ErrorF((char *)msg); -} - -void __glXImpFatal(__GLcontext *gc, char *msg) -{ - ErrorF((char *)msg); - __glXAbort(); -} - -char *__glXImpGetenv(__GLcontext *gc, const char *var) -{ - return __glXGetenv(var); -} - -int __glXImpAtoi(__GLcontext *gc, const char *str) -{ - return __glXAtoi(str); -} - -int __glXImpSprintf(__GLcontext *gc, char *str, const char *fmt, ...) -{ - va_list ap; - int ret; - - /* have to deal with var args */ - va_start(ap, fmt); - ret = __glXVsprintf(str, fmt, ap); - va_end(ap); - - return ret; -} - -void *__glXImpFopen(__GLcontext *gc, const char *path, const char *mode) -{ - return (void *) __glXFopen(path, mode); -} - -int __glXImpFclose(__GLcontext *gc, void *stream) -{ - return __glXFclose((FILE *)stream); -} - -int __glXImpFprintf(__GLcontext *gc, void *stream, const char *fmt, ...) -{ - va_list ap; - int ret; - - /* have to deal with var args */ - va_start(ap, fmt); - ret = __glXVfprintf((FILE *)stream, fmt, ap); - va_end(ap); - - return ret; -} - - -__GLdrawablePrivate *__glXImpGetDrawablePrivate(__GLcontext *gc) -{ - __GLinterface *glci = (__GLinterface *) gc; - __GLXcontext *glrc = (__GLXcontext *) glci->imports.other; - - return &glrc->drawPriv->glPriv; -} - - -__GLdrawablePrivate *__glXImpGetReadablePrivate(__GLcontext *gc) -{ - __GLinterface *glci = (__GLinterface *) gc; - __GLXcontext *glrc = (__GLXcontext *) glci->imports.other; - - return &glrc->readPriv->glPriv; -} diff --git a/GL/glx/glximports.h b/GL/glx/glximports.h deleted file mode 100644 index ef485822e..000000000 --- a/GL/glx/glximports.h +++ /dev/null @@ -1,66 +0,0 @@ -/* $XFree86: xc/programs/Xserver/GL/glx/glximports.h,v 1.3 2001/03/21 16:29:36 dawes Exp $ */ -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#ifndef _glximports_h_ -#define _glximports_h_ - -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -extern void *__glXImpMalloc(__GLcontext *gc, size_t size); -extern void *__glXImpCalloc(__GLcontext *gc, size_t nElem, size_t eSize); -extern void *__glXImpRealloc(__GLcontext *gc, void *addr, size_t newSize); -extern void __glXImpFree(__GLcontext *gc, void *addr); - -extern void __glXImpWarning(__GLcontext *gc, char *msg); -extern void __glXImpFatal(__GLcontext *gc, char *msg); - -extern char *__glXImpGetenv(__GLcontext *gc, const char *var); -extern int __glXImpAtoi(__GLcontext *gc, const char *str); -extern int __glXImpSprintf(__GLcontext *gc, char *str, const char *fmt, ...); -extern void *__glXImpFopen(__GLcontext *gc, const char *path, - const char *mode); -extern int __glXImpFclose(__GLcontext *gc, void *stream); -extern int __glXImpFprintf(__GLcontext *gc, void *stream, - const char *fmt, ...); - -extern __GLdrawablePrivate *__glXImpGetDrawablePrivate(__GLcontext *gc); -extern __GLdrawablePrivate *__glXImpGetReadablePrivate(__GLcontext *gc); - - -#endif /* _glximports_h_ */ - diff --git a/GL/glx/glxmem.c b/GL/glx/glxmem.c deleted file mode 100644 index 21a7c7962..000000000 --- a/GL/glx/glxmem.c +++ /dev/null @@ -1,151 +0,0 @@ -/* $XFree86: xc/programs/Xserver/GL/glx/glxmem.c,v 1.6 2001/10/31 22:50:27 tsi Exp $ */ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -/* -** Implementation of a buffer in main memory -*/ - -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#include "glxserver.h" -#include "glxmem.h" -#include "glxext.h" -#include "GL/internal/glcore.h" - -/* don't want to include glmath.h */ -extern GLuint __glFloorLog2(GLuint); - -/* ---------------------------------------------------------- */ - -#define BUF_ALIGN 32 /* x86 cache alignment (used for assembly paths) */ -#define BUF_ALIGN_MASK (BUF_ALIGN-1) - -static GLboolean -Resize(__GLdrawableBuffer *buf, - GLint x, GLint y, GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, GLuint bufferMask) -{ - GLuint newSize; - void *ubase; - GLint pixelWidth; - GLint alignedWidth; - - /* - ** Note: - ** buf->handle : unaligned base - ** buf->base : aligned base - */ - - pixelWidth = BUF_ALIGN / buf->elementSize; - alignedWidth = (width & ~(pixelWidth-1)) + pixelWidth; - - newSize = alignedWidth * height * buf->elementSize; - - /* - ** Only allocate buffer space for the SGI core. - ** Mesa and Aqua handle their own buffer allocations. - */ -#if defined(__GL_BUFFER_SIZE_TRACKS_WINDOW) - if (__glXCoreType() == GL_CORE_SGI) { -#else - if (newSize > buf->size && __glXCoreType() == GL_CORE_SGI) { -#endif - if (buf->handle) { - ubase = (*glPriv->realloc)(buf->handle, newSize + BUF_ALIGN_MASK); - if (ubase == NULL) { - return GL_FALSE; - } - } else { - ubase = (*glPriv->malloc)(newSize + BUF_ALIGN_MASK); - if (ubase == NULL) { - return GL_FALSE; - } - } - buf->size = newSize; - - buf->handle = ubase; - buf->base = (void *)(((size_t)ubase + BUF_ALIGN_MASK) & - (unsigned int) ~BUF_ALIGN_MASK); - assert(((size_t)buf->base % BUF_ALIGN) == 0); - } - - buf->width = width; - buf->height = height; - buf->byteWidth = alignedWidth * buf->elementSize; - buf->outerWidth = alignedWidth; - - return GL_TRUE; -} - -static void -Lock(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ -} - -static void -Unlock(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ -} - -static void -Free(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ - if (buf->handle) { - (*glPriv->free)(buf->handle); - buf->handle = NULL; - } -} - - -void -__glXInitMem(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, GLint bits) -{ - buf->width = buf->height = 0; /* to be filled during Update */ - buf->depth = bits; - buf->size = 0; - buf->handle = buf->base = NULL; /* to be filled during Update */ - buf->byteWidth = 0; - buf->elementSize = ((bits - 1) / 8) + 1; - buf->elementSizeLog2 = __glFloorLog2(buf->elementSize); - - buf->resize = Resize; - buf->lock = Lock; - buf->unlock = Unlock; - buf->fill = NULL; - buf->free = Free; -} diff --git a/GL/glx/glxmem.h b/GL/glx/glxmem.h deleted file mode 100644 index 06720dfdf..000000000 --- a/GL/glx/glxmem.h +++ /dev/null @@ -1,48 +0,0 @@ -/* $XFree86$ */ -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#ifndef _glxmem_h_ -#define _glxmem_h_ - -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -extern void __glXInitMem(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, - GLint bits); - -#endif /* _glxmem_h_ */ - diff --git a/GL/glx/glxpix.c b/GL/glx/glxpix.c deleted file mode 100644 index 98c033c98..000000000 --- a/GL/glx/glxpix.c +++ /dev/null @@ -1,132 +0,0 @@ -/* $XFree86: xc/programs/Xserver/GL/glx/glxpix.c,v 1.3 2000/09/26 15:57:02 tsi Exp $ */ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -/* -** An implementation of a glx pixmap buffer -*/ - -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#include "glxserver.h" -#include "glxutil.h" -#include "glxpix.h" - -#include <gcstruct.h> - -/* don't want to include glmath.h */ -extern GLuint __glFloorLog2(GLuint); - -typedef struct __GLPixBufferInfoRec { - GCPtr pGC; -} __GLPixBufferInfo; - -/* ---------------------------------------------------------- */ - -static GLboolean -Resize(__GLdrawableBuffer *buf, - GLint x, GLint y, GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, GLuint bufferMask) -{ - buf->width = width; - buf->height = width; - buf->byteWidth = width * buf->elementSize; - buf->outerWidth = width; - - return GL_TRUE; -} - -static void -Lock(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ -} - -static void -Unlock(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ -} - -static void -Free(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv) -{ - __GLPixBufferInfo *bufferInfo; - - if (LookupIDByType((XID)(long)buf->handle, __glXPixmapRes)) { - FreeResource((XID)(long)buf->handle, FALSE); - buf->handle = NULL; - } - - bufferInfo = (__GLPixBufferInfo *) buf->other; - - if (bufferInfo->pGC) { - FreeScratchGC(bufferInfo->pGC); - } - - __glXFree(bufferInfo); - buf->other = NULL; -} - -void -__glXInitPix(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, - GLint bits, XID glxpixmapId, __GLXpixmap *pGlxPixmap) -{ - __GLPixBufferInfo *bufferInfo; - - buf->width = buf->height = 0; /* to be filled during Update */ - buf->depth = bits; - buf->size = 0; - buf->base = NULL; - buf->byteWidth = 0; - buf->elementSize = ((bits-1) / 8) + 1; - buf->elementSizeLog2 = __glFloorLog2(buf->elementSize); - - buf->handle = (void *)(long) glxpixmapId; - pGlxPixmap->refcnt++; - - buf->resize = Resize; - buf->lock = Lock; - buf->unlock = Unlock; - buf->fill = NULL; - buf->free = Free; - - /* allocate local information */ - bufferInfo = (__GLPixBufferInfo *) __glXMalloc(sizeof(__GLPixBufferInfo)); - buf->other = (void *) bufferInfo; - - bufferInfo->pGC = CreateScratchGC(pGlxPixmap->pDraw->pScreen, - pGlxPixmap->pDraw->depth); -} diff --git a/GL/glx/glxpix.h b/GL/glx/glxpix.h deleted file mode 100644 index 4b16352b4..000000000 --- a/GL/glx/glxpix.h +++ /dev/null @@ -1,48 +0,0 @@ -/* $XFree86$ */ -#ifdef HAVE_DIX_CONFIG_H -#include <dix-config.h> -#endif - -#ifndef _glxpix_h_ -#define _glxpix_h_ - -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -** -*/ - -extern void __glXInitPix(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, - GLint bits, XID glxpixmapId, __GLXpixmap *pGlxPixmap); - -#endif /* _glxpix_h_ */ - diff --git a/GL/glx/glxscreens.c b/GL/glx/glxscreens.c index ffe1935e3..aa727a981 100644 --- a/GL/glx/glxscreens.c +++ b/GL/glx/glxscreens.c @@ -38,12 +38,9 @@ #include <dix-config.h> #endif -#ifndef IN_MODULE #include <string.h> -#include <signal.h> -#endif - #include <windowstr.h> +#include <os.h> #include "glxserver.h" #include "glxutil.h" @@ -130,6 +127,7 @@ static char GLXServerExtensions[] = "GLX_EXT_visual_info " "GLX_EXT_visual_rating " "GLX_EXT_import_context " + "GLX_EXT_texture_from_pixmap " "GLX_OML_swap_method " "GLX_SGI_make_current_read " #ifndef __DARWIN__ @@ -140,75 +138,17 @@ static char GLXServerExtensions[] = "GLX_SGIX_fbconfig " ; -/* - * __glDDXScreenInfo comes from GLcore, so we can't resolve this symbol at - * module open time. Leave a placeholder, and fill this in when we first - * need it (in __glXScreenInit). XXX Why make this an array? - */ -static __GLXscreenInfo *__glXScreens[] = { - NULL /* &__glDDXScreenInfo */ , -}; - -static GLint __glXNumStaticScreens = - (sizeof __glXScreens / sizeof __glXScreens[0]); - -__GLXscreenInfo *__glXActiveScreens; -GLint __glXNumActiveScreens; +__GLXscreen **__glXActiveScreens; __GLXSwapBarrierExtensionFuncs *__glXSwapBarrierFuncs = NULL; static int __glXNumSwapBarrierFuncs = 0; __GLXHyperpipeExtensionFuncs *__glXHyperpipeFuncs = NULL; static int __glXNumHyperpipeFuncs = 0; - -RESTYPE __glXDrawableRes; - -__GLXscreenInfo *__glXgetActiveScreen(int num) { - return &__glXActiveScreens[num]; +__GLXscreen *__glXgetActiveScreen(int num) { + return __glXActiveScreens[num]; } -/* -** Destroy routine that gets called when a drawable is freed. A drawable -** contains the ancillary buffers needed for rendering. -*/ -static Bool DrawableGone(__GLXdrawablePrivate *glxPriv, XID xid) -{ - __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. - */ - 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->readGlxc; cx; cx = cx1) { - cx1 = cx->nextReadPriv; - cx->pendingState |= __GLX_PENDING_DESTROY; - } - } - - /* - ** set the size to 0, so that context that may still be using this - ** drawable not do anything harmful - */ - glxPriv->xorigin = 0; - glxPriv->yorigin = 0; - glxPriv->width = 0; - glxPriv->height = 0; - - __glXUnrefDrawablePrivate(glxPriv); - - return True; -} /* ** This hook gets called when a window moves or changes size. @@ -217,7 +157,7 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) { ScreenPtr pScreen; __GLXcontext *glxc; - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; Bool ret; /* @@ -225,7 +165,7 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) */ pScreen = pWin->drawable.pScreen; pScreen->PositionWindow = - __glXActiveScreens[pScreen->myNum].WrappedPositionWindow; + __glXActiveScreens[pScreen->myNum]->WrappedPositionWindow; ret = (*pScreen->PositionWindow)(pWin, x, y); pScreen->PositionWindow = PositionWindow; @@ -233,8 +173,8 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) ** Tell all contexts rendering into this window that the window size ** has changed. */ - glxPriv = (__GLXdrawablePrivate *) LookupIDByType(pWin->drawable.id, - __glXDrawableRes); + glxPriv = (__GLXdrawable *) LookupIDByType(pWin->drawable.id, + __glXDrawableRes); if (glxPriv == NULL) { /* ** This window is not being used by the OpenGL. @@ -246,7 +186,7 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) ** resize the drawable */ /* first change the drawable size */ - if (__glXResizeDrawableBuffers(glxPriv) == GL_FALSE) { + if (glxPriv->resize(glxPriv) == GL_FALSE) { /* resize failed! */ /* XXX: what can we possibly do here? */ ret = False; @@ -266,18 +206,6 @@ static Bool PositionWindow(WindowPtr pWin, int x, int y) } /* -** Wrap our own PositionWindow routine around the server's, so we can -** be notified when a window changes size -*/ -static void wrapPositionWindow(int screen) -{ - ScreenPtr pScreen = screenInfo.screens[screen]; - - __glXActiveScreens[screen].WrappedPositionWindow = pScreen->PositionWindow; - pScreen->PositionWindow = PositionWindow; -} - -/* * If your DDX driver wants to register support for swap barriers or hyperpipe * topology, it should call __glXHyperpipeInit() or __glXSwapBarrierInit() * with a dispatch table of functions to handle the requests. In the XFree86 @@ -320,57 +248,80 @@ void __glXSwapBarrierInit(int screen, __GLXSwapBarrierExtensionFuncs *funcs) funcs->queryMaxSwapBarriersFunc; } -void __glXScreenInit(GLint numscreens) +static __GLXprovider *__glXProviderStack; + +void GlxPushProvider(__GLXprovider *provider) +{ + provider->next = __glXProviderStack; + __glXProviderStack = provider; +} + +void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen) +{ + screen->pScreen = pScreen; + screen->GLextensions = __glXStrdup(GLServerExtensions); + screen->GLXvendor = __glXStrdup(GLXServerVendorName); + screen->GLXversion = __glXStrdup(GLXServerVersion); + screen->GLXextensions = __glXStrdup(GLXServerExtensions); + + screen->WrappedPositionWindow = pScreen->PositionWindow; + pScreen->PositionWindow = PositionWindow; + + __glXScreenInitVisuals(screen); +} + +void +__glXScreenDestroy(__GLXscreen *screen) { - GLint i,j; + __glXFree(screen->GLXvendor); + __glXFree(screen->GLXversion); + __glXFree(screen->GLXextensions); + __glXFree(screen->GLextensions); +} - __glXScreens[0] = __glXglDDXScreenInfo(); /* from GLcore */ +void __glXInitScreens(void) +{ + GLint i; + ScreenPtr pScreen; + __GLXprovider *p; + size_t size; /* ** This alloc has to work or else the server might as well core dump. */ - __glXActiveScreens = - (__GLXscreenInfo *) __glXMalloc(sizeof(__GLXscreenInfo) * numscreens); + size = screenInfo.numScreens * sizeof(__GLXscreen *); + __glXActiveScreens =__glXMalloc(size); + __glXMemset(__glXActiveScreens, 0, size); - for (i=0; i < numscreens; i++) { - /* - ** Probe each static screen to see which exists. - */ - for (j=0; j < __glXNumStaticScreens; j++) { - if ((*__glXScreens[j]->screenProbe)(i)) { - __glXActiveScreens[i] = *__glXScreens[j]; - - __glXActiveScreens[i].numUsableVisuals = __glXActiveScreens[i].numVisuals; - __glXActiveScreens[i].GLextensions = __glXStrdup(GLServerExtensions); - __glXActiveScreens[i].GLXvendor = __glXStrdup(GLXServerVendorName); - __glXActiveScreens[i].GLXversion = __glXStrdup(GLXServerVersion); - __glXActiveScreens[i].GLXextensions = __glXStrdup(GLXServerExtensions); - - __glXDrawableRes = CreateNewResourceType((DeleteType)DrawableGone); - wrapPositionWindow(i); + 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; } } } - __glXNumActiveScreens = numscreens; } -void __glXScreenReset(void) +void __glXResetScreens(void) { int i; - for (i = 0; i < __glXNumActiveScreens; i++) { - __glXFree(__glXActiveScreens[i].GLXvendor); - __glXFree(__glXActiveScreens[i].GLXversion); - __glXFree(__glXActiveScreens[i].GLXextensions); - __glXFree(__glXActiveScreens[i].GLextensions); - } - xfree(__glXActiveScreens); - xfree(__glXHyperpipeFuncs); - xfree(__glXSwapBarrierFuncs); - __glXNumHyperpipeFuncs = 0; - __glXNumSwapBarrierFuncs = 0; - __glXHyperpipeFuncs = NULL; - __glXSwapBarrierFuncs = NULL; - __glXActiveScreens = NULL; - __glXNumActiveScreens = 0; + for (i = 0; i < screenInfo.numScreens; i++) + if (__glXActiveScreens[i]) + __glXActiveScreens[i]->destroy(__glXActiveScreens[i]); + + __glXFree(__glXActiveScreens); + __glXFree(__glXHyperpipeFuncs); + __glXFree(__glXSwapBarrierFuncs); + __glXNumHyperpipeFuncs = 0; + __glXNumSwapBarrierFuncs = 0; + __glXHyperpipeFuncs = NULL; + __glXSwapBarrierFuncs = NULL; + __glXActiveScreens = NULL; } diff --git a/GL/glx/glxscreens.h b/GL/glx/glxscreens.h index 2d68c8b60..8a2b2388f 100644 --- a/GL/glx/glxscreens.h +++ b/GL/glx/glxscreens.h @@ -51,28 +51,15 @@ ** and DDX layers of the GLX server extension. The methods provide an ** interface for context management on a screen. */ -typedef struct { - /* - ** Probe the screen and see if it supports GL rendering. It will - ** return GL_FALSE if it doesn't, GL_TRUE otherwise. - */ - Bool (*screenProbe)(int screen); +typedef struct __GLXscreen __GLXscreen; +struct __GLXscreen { + void (*destroy)(__GLXscreen *screen); - /* - ** Create a context using configuration information from modes. - ** Use imports as callbacks back to the OS. Return an opaque handle - ** on the context (NULL if failure). - */ - __GLinterface *(*createContext)(__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC); + __GLXcontext *(*createContext)(__GLXscreen *screen, + __GLcontextModes *modes, + __GLXcontext *shareContext); - /* - ** Create a buffer using information from glxPriv. This routine - ** sets up any wrappers necessary to resize, swap or destroy the - ** buffer. - */ - void (*createBuffer)(__GLXdrawablePrivate *glxPriv); + ScreenPtr pScreen; /** * Linked list of valid context modes for this screen. @@ -94,10 +81,13 @@ typedef struct { */ Bool (*WrappedPositionWindow)(WindowPtr pWin, int x, int y); -} __GLXscreenInfo; +}; + +void __glXScreenInit(__GLXscreen *screen, ScreenPtr pScreen); +void __glXScreenDestroy(__GLXscreen *screen); -extern void __glXScreenInit(GLint); -extern void __glXScreenReset(void); +void __glXInitScreens(void); +extern void __glXResetScreens(void); #endif /* !__GLX_screens_h__ */ diff --git a/GL/glx/glxserver.h b/GL/glx/glxserver.h index 2609b1674..2e273b970 100644 --- a/GL/glx/glxserver.h +++ b/GL/glx/glxserver.h @@ -53,7 +53,6 @@ #include <scrnintstr.h> #include "GL/glx_ansic.h" - /* ** The X header misc.h defines these math functions. */ @@ -66,7 +65,8 @@ #include <GL/glxint.h> /* For glxscreens.h */ -typedef struct __GLXdrawablePrivateRec __GLXdrawablePrivate; +typedef struct __GLXdrawable __GLXdrawable; +typedef struct __GLXcontext __GLXcontext; #include "glxscreens.h" #include "glxdrawable.h" @@ -91,15 +91,19 @@ typedef XID GLXContextID; typedef XID GLXPixmap; typedef XID GLXDrawable; -typedef struct __GLXcontextRec *GLXContext; typedef struct __GLXclientStateRec __GLXclientState; -extern __GLXscreenInfo *__glXActiveScreens; +extern __GLXscreen **__glXActiveScreens; extern GLint __glXNumActiveScreens; -extern __GLXscreenInfo *__glXgetActiveScreen(int num); +extern __GLXscreen *__glXgetActiveScreen(int num); /************************************************************************/ +void GlxSetVisualConfigs(int nconfigs, + __GLXvisualConfig *configs, void **privates); + +void __glXScreenInitVisuals(__GLXscreen *screen); + /* ** The last context used (from the server's persective) is cached. */ @@ -116,6 +120,20 @@ extern __GLXcontext *__glXForceCurrent(__GLXclientState*, GLXContextTag, int*); /************************************************************************/ +typedef struct __GLXprovider __GLXprovider; +struct __GLXprovider { + __GLXscreen *(*screenProbe)(ScreenPtr pScreen); + const char *name; + __GLXprovider *next; +}; + +void GlxPushProvider(__GLXprovider *provider); + +void __glXsetEnterLeaveServerFuncs(void (*enter)(void), + void (*leave)(void)); +void __glXenterServer(void); +void __glXleaveServer(void); + /* ** State kept per client. */ @@ -214,6 +232,8 @@ extern void __glXSwapQueryVersionReply(ClientPtr client, extern void __glXSwapQueryContextInfoEXTReply(ClientPtr client, xGLXQueryContextInfoEXTReply *reply, int *buf); +extern void __glXSwapGetDrawableAttributesReply(ClientPtr client, + xGLXGetDrawableAttributesReply *reply, CARD32 *buf); extern void glxSwapQueryExtensionsStringReply(ClientPtr client, xGLXQueryExtensionsStringReply *reply, char *buf); extern void glxSwapQueryServerStringReply(ClientPtr client, diff --git a/GL/glx/glxutil.c b/GL/glx/glxutil.c index 25586433f..8937d12aa 100644 --- a/GL/glx/glxutil.c +++ b/GL/glx/glxutil.c @@ -48,7 +48,6 @@ #include <pixmapstr.h> #include <windowstr.h> #include "glxutil.h" -#include "glxbuf.h" #include "GL/glx_ansic.h" #include "GL/internal/glcore.h" #include "GL/glxint.h" @@ -56,10 +55,6 @@ /************************************************************************/ -void __glXNop(void) {} - -/************************************************************************/ - /* Memory Allocation for GLX */ void * @@ -93,7 +88,7 @@ __glXCalloc(size_t numElements, size_t elementSize) /* XXX: handle out of memory error */ return NULL; } - __glXMemset(addr, 0, size); + memset(addr, 0, size); return addr; } @@ -144,13 +139,13 @@ __glXAssociateContext(__GLXcontext *glxc) glxc->nextDrawPriv = glxc->drawPriv->drawGlxc; glxc->drawPriv->drawGlxc = glxc; - __glXRefDrawablePrivate(glxc->drawPriv); + __glXRefDrawable(glxc->drawPriv); glxc->nextReadPriv = glxc->readPriv->readGlxc; glxc->readPriv->readGlxc = glxc; - __glXRefDrawablePrivate(glxc->readPriv); + __glXRefDrawable(glxc->readPriv); } /* @@ -173,7 +168,7 @@ __glXDeassociateContext(__GLXcontext *glxc) prev->nextDrawPriv = curr->nextDrawPriv; } curr->nextDrawPriv = NULL; - __glXUnrefDrawablePrivate(glxc->drawPriv); + __glXUnrefDrawable(glxc->drawPriv); break; } } @@ -191,319 +186,72 @@ __glXDeassociateContext(__GLXcontext *glxc) prev->nextReadPriv = curr->nextReadPriv; } curr->nextReadPriv = NULL; - __glXUnrefDrawablePrivate(glxc->readPriv); + __glXUnrefDrawable(glxc->readPriv); break; } } } -/************************************************************************/ - -void -__glXGetDrawableSize(__GLdrawablePrivate *glPriv, - GLint *x, GLint *y, GLuint *width, GLuint *height) -{ - __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other; - - if (glxPriv) { - *x = glxPriv->xorigin; - *y = glxPriv->yorigin; - *width = glxPriv->width; - *height = glxPriv->height; - } else { - *x = *y = *width = *height = 0; - } -} - -GLboolean -__glXResizeDrawable(__GLdrawablePrivate *glPriv) -{ - /* nothing to be done here */ - return GL_TRUE; -} - - -/*****************************************************************************/ -/* accessing the drawable private */ - -static void -LockDP(__GLdrawablePrivate *glPriv, __GLcontext *gc) -{ - __GLinterface *glci = (__GLinterface *) gc; - __GLXcontext *glxc = (__GLXcontext *) glci->imports.other; - - /* quick exit test */ - if ((glxc->pendingState & - (__GLX_PENDING_RESIZE | - __GLX_PENDING_DESTROY | - __GLX_PENDING_SWAP)) == 0x0) - return; - - /* some pending state. Deal with it */ - if (glxc->pendingState & __GLX_PENDING_RESIZE) { - glxc->pendingState &= ~__GLX_PENDING_RESIZE; - - (*glci->exports.notifyResize)(gc); - assert((glxc->pendingState & __GLX_PENDING_RESIZE) == 0x0); - } - if (glxc->pendingState & __GLX_PENDING_DESTROY) { - glxc->pendingState &= ~__GLX_PENDING_DESTROY; - - assert(glxc->drawPriv->xorigin == 0); - assert(glxc->drawPriv->yorigin == 0); - assert(glxc->drawPriv->width == 0); - assert(glxc->drawPriv->height == 0); - assert(glxc->readPriv->xorigin == 0); - assert(glxc->readPriv->yorigin == 0); - assert(glxc->readPriv->width == 0); - assert(glxc->readPriv->height == 0); - (*glci->exports.notifyDestroy)(gc); - __glXDeassociateContext(glxc); - assert((glxc->pendingState & __GLX_PENDING_DESTROY) == 0x0); - } - if (glxc->pendingState & __GLX_PENDING_SWAP) { - - glxc->pendingState &= ~__GLX_PENDING_SWAP; - - (*glci->exports.notifySwapBuffers)(gc); - assert((glxc->pendingState & __GLX_PENDING_SWAP) == 0x0); - } -} - -static void -UnlockDP(__GLdrawablePrivate *glPriv) -{ -} - /*****************************************************************************/ /* Drawable private stuff */ void -__glXRefDrawablePrivate(__GLXdrawablePrivate *glxPriv) +__glXRefDrawable(__GLXdrawable *glxPriv) { glxPriv->refCount++; } void -__glXUnrefDrawablePrivate(__GLXdrawablePrivate *glxPriv) +__glXUnrefDrawable(__GLXdrawable *glxPriv) { glxPriv->refCount--; if (glxPriv->refCount == 0) { - __glXDestroyDrawablePrivate(glxPriv); + /* remove the drawable from the drawable list */ + FreeResourceByType(glxPriv->drawId, __glXDrawableRes, FALSE); + glxPriv->destroy(glxPriv); } } -__GLXdrawablePrivate * -__glXCreateDrawablePrivate(DrawablePtr pDraw, XID drawId, - __GLcontextModes *modes) +GLboolean +__glXDrawableInit(__GLXdrawable *drawable, + __GLXcontext *ctx, DrawablePtr pDraw, XID drawId) { - __GLXdrawablePrivate *glxPriv; - __GLdrawablePrivate *glPriv; - __GLXscreenInfo *pGlxScreen; - - glxPriv = (__GLXdrawablePrivate *) __glXMalloc(sizeof(*glxPriv)); - __glXMemset(glxPriv, 0, sizeof(__GLXdrawablePrivate)); - - glxPriv->type = pDraw->type; - glxPriv->pDraw = pDraw; - glxPriv->drawId = drawId; + drawable->type = pDraw->type; + drawable->pDraw = pDraw; + drawable->drawId = drawId; + drawable->refCount = 1; /* if not a pixmap, lookup will fail, so pGlxPixmap will be NULL */ - glxPriv->pGlxPixmap = (__GLXpixmap *) + drawable->pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId, __glXPixmapRes); - /* since we are creating the drawablePrivate, drawId should be new */ - if (!AddResource(drawId, __glXDrawableRes, glxPriv)) { - /* oops! */ - __glXFree(glxPriv); - return NULL; - } - - /* fill up glPriv */ - glPriv = &glxPriv->glPriv; - glPriv->modes = (__GLcontextModes *) __glXMalloc(sizeof(__GLcontextModes)); - *glPriv->modes = *modes; - glPriv->malloc = __glXMalloc; - glPriv->calloc = __glXCalloc; - glPriv->realloc = __glXRealloc; - glPriv->free = __glXFree; - glPriv->addSwapRect = NULL; - glPriv->setClipRect = (void (*)(__GLdrawablePrivate *, GLint, GLint, GLsizei, GLsizei)) __glXNop; - glPriv->lockDP = LockDP; - glPriv->unlockDP = UnlockDP; - glPriv->getDrawableSize = __glXGetDrawableSize; - glPriv->resize = __glXResizeDrawable; - glPriv->other = glxPriv; - - /* allocate a one-rect ownership region */ - glPriv->ownershipRegion.rects = - (__GLregionRect *)__glXCalloc(1, sizeof(__GLregionRect)); - glPriv->ownershipRegion.numRects = 1; - - glxPriv->freeBuffers = __glXFreeBuffers; - glxPriv->updatePalette = (void (*)(__GLXdrawablePrivate *)) __glXNop; - - pGlxScreen = &__glXActiveScreens[pDraw->pScreen->myNum]; - - if (glxPriv->type == DRAWABLE_WINDOW) { - VisualID vid = wVisual((WindowPtr)pDraw); - - glxPriv->modes = _gl_context_modes_find_visual( pGlxScreen->modes, vid ); - __glXFBInitDrawable(glxPriv, modes); - } else { - glxPriv->modes = glxPriv->pGlxPixmap->modes; - __glXPixInitDrawable(glxPriv, modes); - } - - /* initialize the core's private buffer information */ - (*pGlxScreen->createBuffer)(glxPriv); - - return glxPriv; -} -GLboolean -__glXDestroyDrawablePrivate(__GLXdrawablePrivate *glxPriv) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - - /* remove the drawable from the drawable list */ - FreeResourceByType(glxPriv->drawId, __glXDrawableRes, FALSE); - - /* Have the core free any memory it may have attached to the drawable */ - if (glPriv->freePrivate) { - (*glPriv->freePrivate)(glPriv); - } - - /* Free any framebuffer memory attached to the drawable */ - if (glxPriv->freeBuffers) { - (*glxPriv->freeBuffers)(glxPriv); + /* since we are creating the drawablePrivate, drawId should be new */ + if (!AddResource(drawId, __glXDrawableRes, drawable)) { + return GL_FALSE; } - /* Free the drawable Private */ - __glXFree(glxPriv->glPriv.modes); - __glXFree(glxPriv->glPriv.ownershipRegion.rects); - __glXFree(glxPriv); - return GL_TRUE; } -__GLXdrawablePrivate * -__glXFindDrawablePrivate(XID drawId) +__GLXdrawable * +__glXFindDrawable(XID drawId) { - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; - glxPriv = (__GLXdrawablePrivate *)LookupIDByType(drawId, __glXDrawableRes); + glxPriv = (__GLXdrawable *)LookupIDByType(drawId, __glXDrawableRes); return glxPriv; } -__GLXdrawablePrivate * -__glXGetDrawablePrivate(DrawablePtr pDraw, XID drawId, - __GLcontextModes *modes) +__GLXdrawable * +__glXGetDrawable(__GLXcontext *ctx, DrawablePtr pDraw, XID drawId) { - __GLXdrawablePrivate *glxPriv; + __GLXdrawable *glxPriv; - glxPriv = __glXFindDrawablePrivate(drawId); + glxPriv = __glXFindDrawable(drawId); - if (glxPriv == NULL) { - glxPriv = __glXCreateDrawablePrivate(pDraw, drawId, modes); - if (glxPriv) { - __glXRefDrawablePrivate(glxPriv); - } - } + if (glxPriv == NULL) + glxPriv = ctx->createDrawable(ctx, pDraw, drawId); return glxPriv; } - -void -__glXCacheDrawableSize(__GLXdrawablePrivate *glxPriv) -{ - if (glxPriv) { - if (glxPriv->pDraw) { - glxPriv->xorigin = glxPriv->pDraw->x; - glxPriv->yorigin = glxPriv->pDraw->y; - glxPriv->width = glxPriv->pDraw->width; - glxPriv->height = glxPriv->pDraw->height; - } - } -} - -/* -** resize/move the drawable. Called during the actual resize callback -** to update the drawable side of the buffers -*/ -GLboolean -__glXResizeDrawableBuffers(__GLXdrawablePrivate *glxPriv) -{ - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - GLint x, y; - GLuint w, h; -#if defined(__GL_ALIGNED_BUFFERS) - GLint xAlignment, yAlignment; - GLint xOffset, yOffset; - GLint xStart, xEnd; - GLint yStart, yEnd; - GLuint xAlignedMask, yAlignedMask; -#endif - GLboolean status = GL_TRUE; - - __glXCacheDrawableSize(glxPriv); - - w = glxPriv->width; - h = glxPriv->height; - x = glxPriv->xorigin; - y = glxPriv->yorigin; - -#if defined(__GL_ALIGNED_BUFFERS) - xAlignment = glPriv->xAlignment; - yAlignment = glPriv->yAlignment; - - xOffset = x & (xAlignment-1); - yOffset = y & (yAlignment-1); - - xAlignedMask = ~(xAlignment-1); - yAlignedMask = ~(yAlignment-1); - - xStart = x; xEnd = x+w; - yStart = y; yEnd = y+h; - - xStart &= xAlignedMask; - if (xEnd & ~xAlignedMask) { - xEnd = (xEnd&xAlignedMask) + xAlignment; - } - yStart &= yAlignedMask; - if (yEnd & ~yAlignedMask) { - yEnd = (yEnd&yAlignedMask) + yAlignment; - } - - x = xStart; y = yStart; - w = xEnd-xStart; h = yEnd-yStart; -#endif - - if ((x != glPriv->xOrigin) || - (y != glPriv->yOrigin) || -#if defined(__GL_ALIGNED_BUFFERS) - (xOffset != glPriv->xOffset) || - (yOffset != glPriv->yOffset) || -#endif - (w != glPriv->width) || - (h != glPriv->height) || - (!w && !h)) { - /* set up the glPriv info */ - glPriv->width = w; - glPriv->height = h; - glPriv->xOrigin = x; - glPriv->yOrigin = y; -#if defined(__GL_ALIGNED_BUFFERS) - glPriv->xOffset = xOffset; - glPriv->yOffset = yOffset; -#endif - - /* notify the buffers */ - status = __glXResizeBuffers(glPriv, x, y, w, h); - } - - return status; -} - -/************************************************************************/ - diff --git a/GL/glx/glxutil.h b/GL/glx/glxutil.h index 2c3090a46..07384bf76 100644 --- a/GL/glx/glxutil.h +++ b/GL/glx/glxutil.h @@ -58,20 +58,23 @@ extern void __glXGetDrawableSize(__GLdrawablePrivate *glPriv, GLint *x, GLint *y, GLuint *width, GLuint *height); extern GLboolean __glXResizeDrawable(__GLdrawablePrivate *glPriv); -extern GLboolean __glXResizeDrawableBuffers(__GLXdrawablePrivate *glxPriv); +extern GLboolean __glXResizeDrawableBuffers(__GLXdrawable *glxPriv); /* drawable management */ -extern void __glXRefDrawablePrivate(__GLXdrawablePrivate *glxPriv); -extern void __glXUnrefDrawablePrivate(__GLXdrawablePrivate *glxPriv); -extern __GLXdrawablePrivate *__glXCreateDrawablePrivate(DrawablePtr pDraw, - XID glxpixmapId, - __GLcontextModes *modes); -extern GLboolean __glXDestroyDrawablePrivate(__GLXdrawablePrivate *glxPriv); -extern __GLXdrawablePrivate *__glXFindDrawablePrivate(XID glxpixmapId); -extern __GLXdrawablePrivate *__glXGetDrawablePrivate(DrawablePtr pDraw, - XID glxpixmapId, - __GLcontextModes *modes); -extern void __glXCacheDrawableSize(__GLXdrawablePrivate *glxPriv); +extern void __glXRefDrawable(__GLXdrawable *glxPriv); +extern void __glXUnrefDrawable(__GLXdrawable *glxPriv); + +extern __GLXdrawable *__glXCreateDrawable(__GLXcontext *ctx, + DrawablePtr pDraw, + XID glxpixmapId); +extern GLboolean __glXDrawableInit(__GLXdrawable *drawable, __GLXcontext *ctx, + DrawablePtr pDraw, XID drawID); +extern GLboolean __glXDestroyDrawable(__GLXdrawable *glxPriv); +extern __GLXdrawable *__glXFindDrawable(XID glxpixmapId); +extern __GLXdrawable *__glXGetDrawable(__GLXcontext *ctx, + DrawablePtr pDraw, + XID glxpixmapId); +extern void __glXCacheDrawableSize(__GLXdrawable *glxPriv); /* context helper routines */ extern __GLXcontext *__glXLookupContextByTag(__GLXclientState*, GLXContextTag); diff --git a/GL/glx/glxvisuals.c b/GL/glx/glxvisuals.c new file mode 100644 index 000000000..9b5839ce9 --- /dev/null +++ b/GL/glx/glxvisuals.c @@ -0,0 +1,517 @@ +/* + * Copyright © 2006 Red Hat, Inc. + * (C) Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * RED HAT, INC, OR PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT + * OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * Authors: + * Kevin E. Martin <kevin@precisioninsight.com> + * Brian Paul <brian@precisioninsight.com> + * Kristian Høgsberg <krh@redhat.com> + * + */ + +#ifdef HAVE_DIX_CONFIG_H +#include <dix-config.h> +#endif + +#include <string.h> +#include <regionstr.h> +#include <resource.h> +#include <GL/gl.h> +#include <GL/glxint.h> +#include <GL/glxtokens.h> +#include <GL/internal/glcore.h> +#include <scrnintstr.h> +#include <config.h> +#include <glxserver.h> +#include <glxscreens.h> +#include <glxdrawable.h> +#include <glxcontext.h> +#include <glxext.h> +#include <glxutil.h> +#include <micmap.h> + +void GlxWrapInitVisuals(miInitVisualsProcPtr *); + +#include "glcontextmodes.h" + +struct ScreenVisualsRec { + int num_vis; + void *private; + __GLcontextModes *modes; +}; +typedef struct ScreenVisualsRec ScreenVisuals; + +static ScreenVisuals screenVisuals[MAXSCREENS]; + +static int numConfigs = 0; +static __GLXvisualConfig *visualConfigs = NULL; +static void **visualPrivates = NULL; + +static int count_bits(unsigned int n) +{ + int bits = 0; + + while (n > 0) { + if (n & 1) bits++; + n >>= 1; + } + return bits; +} + +/* + * In the case the driver defines no GLX visuals we'll use these. + * Note that for TrueColor and DirectColor visuals, bufferSize is the + * sum of redSize, greenSize, blueSize and alphaSize, which may be larger + * than the nplanes/rootDepth of the server's X11 visuals + */ +#define NUM_FALLBACK_CONFIGS 5 +static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = { + /* [0] = RGB, double buffered, Z */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 0, /* rgba sizes */ + -1, -1, -1, 0, /* rgba masks */ + 0, 0, 0, 0, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 0, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [1] = RGB, double buffered, Z, stencil, accum */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 0, /* rgba sizes */ + -1, -1, -1, 0, /* rgba masks */ + 16, 16, 16, 0, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 8, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 8, /* rgba sizes */ + -1, -1, -1, -1, /* rgba masks */ + 16, 16, 16, 16, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 8, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */ + { + -1, /* vid */ + -1, /* class */ + True, /* rgba */ + -1, -1, -1, 8, /* rgba sizes */ + -1, -1, -1, -1, /* rgba masks */ + 16, 16, 16, 16, /* rgba accum sizes */ + False, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 8, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, + /* [4] = CI, double buffered, Z */ + { + -1, /* vid */ + -1, /* class */ + False, /* rgba? (false = color index) */ + -1, -1, -1, 0, /* rgba sizes */ + -1, -1, -1, 0, /* rgba masks */ + 0, 0, 0, 0, /* rgba accum sizes */ + True, /* doubleBuffer */ + False, /* stereo */ + -1, /* bufferSize */ + 16, /* depthSize */ + 0, /* stencilSize */ + 0, /* auxBuffers */ + 0, /* level */ + GLX_NONE, /* visualRating */ + GLX_NONE, /* transparentPixel */ + 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ + 0 /* transparentIndex */ + }, +}; + + +static Bool init_visuals(int *nvisualp, VisualPtr *visualp, + VisualID *defaultVisp, + int ndepth, DepthPtr pdepth, + int rootDepth) +{ + int numRGBconfigs; + int numCIconfigs; + int numVisuals = *nvisualp; + int numNewVisuals; + int numNewConfigs; + VisualPtr pVisual = *visualp; + VisualPtr pVisualNew = NULL; + VisualID *orig_vid = NULL; + __GLcontextModes *modes; + __GLXvisualConfig *pNewVisualConfigs = NULL; + void **glXVisualPriv; + void **pNewVisualPriv; + int found_default; + int i, j, k; + + if (numConfigs > 0) + numNewConfigs = numConfigs; + else + numNewConfigs = NUM_FALLBACK_CONFIGS; + + /* Alloc space for the list of new GLX visuals */ + pNewVisualConfigs = (__GLXvisualConfig *) + __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig)); + if (!pNewVisualConfigs) { + return FALSE; + } + + /* Alloc space for the list of new GLX visual privates */ + pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *)); + if (!pNewVisualPriv) { + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* + ** If SetVisualConfigs was not called, then use default GLX + ** visual configs. + */ + if (numConfigs == 0) { + memcpy(pNewVisualConfigs, FallbackConfigs, + NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig)); + memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *)); + } + else { + /* copy driver's visual config info */ + for (i = 0; i < numConfigs; i++) { + pNewVisualConfigs[i] = visualConfigs[i]; + pNewVisualPriv[i] = visualPrivates[i]; + } + } + + /* Count the number of RGB and CI visual configs */ + numRGBconfigs = 0; + numCIconfigs = 0; + for (i = 0; i < numNewConfigs; i++) { + if (pNewVisualConfigs[i].rgba) + numRGBconfigs++; + else + numCIconfigs++; + } + + /* Count the total number of visuals to compute */ + numNewVisuals = 0; + for (i = 0; i < numVisuals; i++) { + numNewVisuals += + (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor) + ? numRGBconfigs : numCIconfigs; + } + + /* Reset variables for use with the next screen/driver's visual configs */ + visualConfigs = NULL; + numConfigs = 0; + + /* Alloc temp space for the list of orig VisualIDs for each new visual */ + orig_vid = (VisualID *) __glXMalloc(numNewVisuals * sizeof(VisualID)); + if (!orig_vid) { + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Alloc space for the list of glXVisuals */ + modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes)); + if (modes == NULL) { + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Alloc space for the list of glXVisualPrivates */ + glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *)); + if (!glXVisualPriv) { + _gl_context_modes_destroy( modes ); + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Alloc space for the new list of the X server's visuals */ + pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec)); + if (!pVisualNew) { + __glXFree(glXVisualPriv); + _gl_context_modes_destroy( modes ); + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + return FALSE; + } + + /* Initialize the new visuals */ + found_default = FALSE; + screenVisuals[screenInfo.numScreens-1].modes = modes; + for (i = j = 0; i < numVisuals; i++) { + int is_rgb = (pVisual[i].class == TrueColor || + pVisual[i].class == DirectColor); + + for (k = 0; k < numNewConfigs; k++) { + if (pNewVisualConfigs[k].rgba != is_rgb) + continue; + + assert( modes != NULL ); + + /* Initialize the new visual */ + pVisualNew[j] = pVisual[i]; + pVisualNew[j].vid = FakeClientID(0); + + /* Check for the default visual */ + if (!found_default && pVisual[i].vid == *defaultVisp) { + *defaultVisp = pVisualNew[j].vid; + found_default = TRUE; + } + + /* Save the old VisualID */ + orig_vid[j] = pVisual[i].vid; + + /* Initialize the glXVisual */ + _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] ); + modes->visualID = pVisualNew[j].vid; + if (modes->fbconfigID == GLX_DONT_CARE) + modes->fbconfigID = modes->visualID; + + /* + * If the class is -1, then assume the X visual information + * is identical to what GLX needs, and take them from the X + * visual. NOTE: if class != -1, then all other fields MUST + * be initialized. + */ + if (modes->visualType == GLX_NONE) { + modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class ); + modes->redBits = count_bits(pVisual[i].redMask); + modes->greenBits = count_bits(pVisual[i].greenMask); + modes->blueBits = count_bits(pVisual[i].blueMask); + modes->alphaBits = modes->alphaBits; + modes->redMask = pVisual[i].redMask; + modes->greenMask = pVisual[i].greenMask; + modes->blueMask = pVisual[i].blueMask; + modes->alphaMask = modes->alphaMask; + modes->rgbBits = (is_rgb) + ? (modes->redBits + modes->greenBits + + modes->blueBits + modes->alphaBits) + : rootDepth; + } + + /* Save the device-dependent private for this visual */ + glXVisualPriv[j] = pNewVisualPriv[k]; + + j++; + modes = modes->next; + } + } + + assert(j <= numNewVisuals); + + /* Save the GLX visuals in the screen structure */ + screenVisuals[screenInfo.numScreens-1].num_vis = numNewVisuals; + screenVisuals[screenInfo.numScreens-1].private = glXVisualPriv; + + /* Set up depth's VisualIDs */ + for (i = 0; i < ndepth; i++) { + int numVids = 0; + VisualID *pVids = NULL; + int k, n = 0; + + /* Count the new number of VisualIDs at this depth */ + for (j = 0; j < pdepth[i].numVids; j++) + for (k = 0; k < numNewVisuals; k++) + if (pdepth[i].vids[j] == orig_vid[k]) + numVids++; + + /* Allocate a new list of VisualIDs for this depth */ + pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID)); + + /* Initialize the new list of VisualIDs for this depth */ + for (j = 0; j < pdepth[i].numVids; j++) + for (k = 0; k < numNewVisuals; k++) + if (pdepth[i].vids[j] == orig_vid[k]) + pVids[n++] = pVisualNew[k].vid; + + /* Update this depth's list of VisualIDs */ + __glXFree(pdepth[i].vids); + pdepth[i].vids = pVids; + pdepth[i].numVids = numVids; + } + + /* Update the X server's visuals */ + *nvisualp = numNewVisuals; + *visualp = pVisualNew; + + /* Free the old list of the X server's visuals */ + __glXFree(pVisual); + + /* Clean up temporary allocations */ + __glXFree(orig_vid); + __glXFree(pNewVisualPriv); + __glXFree(pNewVisualConfigs); + + /* Free the private list created by DDX HW driver */ + if (visualPrivates) + __glXFree(visualPrivates); + visualPrivates = NULL; + + return TRUE; +} + +void GlxSetVisualConfigs(int nconfigs, + __GLXvisualConfig *configs, void **privates) +{ + numConfigs = nconfigs; + visualConfigs = configs; + visualPrivates = privates; +} + +static miInitVisualsProcPtr saveInitVisualsProc; + +static Bool __glXInitVisuals(VisualPtr *visualp, DepthPtr *depthp, + int *nvisualp, int *ndepthp, + int *rootDepthp, VisualID *defaultVisp, + unsigned long sizes, int bitsPerRGB, + int preferredVis) +{ + Bool ret; + + if (saveInitVisualsProc) { + ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp, + rootDepthp, defaultVisp, sizes, bitsPerRGB, + preferredVis); + if (!ret) + return False; + } + + /* + * Setup the visuals supported by this particular screen. + */ + init_visuals(nvisualp, visualp, defaultVisp, + *ndepthp, *depthp, *rootDepthp); + + + return True; +} + + +/************************************************************************/ + + +void +GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc) +{ + saveInitVisualsProc = *initVisProc; + *initVisProc = __glXInitVisuals; +} + +static void fixup_visuals(int screen) +{ + ScreenPtr pScreen = screenInfo.screens[screen]; + ScreenVisuals *psv = &screenVisuals[screen]; + int j; + __GLcontextModes *modes; + + for ( modes = psv->modes ; modes != NULL ; modes = modes->next ) { + const int vis_class = _gl_convert_to_x_visual_type( modes->visualType ); + const int nplanes = (modes->rgbBits - modes->alphaBits); + const VisualPtr pVis = pScreen->visuals; + + /* Find a visual that matches the GLX visual's class and size */ + for (j = 0; j < pScreen->numVisuals; j++) { + if (pVis[j].class == vis_class && + pVis[j].nplanes == nplanes) { + + /* Fixup the masks */ + modes->redMask = pVis[j].redMask; + modes->greenMask = pVis[j].greenMask; + modes->blueMask = pVis[j].blueMask; + + /* Recalc the sizes */ + modes->redBits = count_bits(modes->redMask); + modes->greenBits = count_bits(modes->greenMask); + modes->blueBits = count_bits(modes->blueMask); + } + } + } +} + +void __glXScreenInitVisuals(__GLXscreen *screen) +{ + int index = screen->pScreen->myNum; + + screen->modes = screenVisuals[index].modes; + screen->pVisualPriv = screenVisuals[index].private; + screen->numVisuals = screenVisuals[index].num_vis; + screen->numUsableVisuals = screenVisuals[index].num_vis; + + /* + * The ordering of the rgb compenents might have been changed by the + * driver after mi initialized them. + */ + fixup_visuals(index); +} diff --git a/GL/mesa/X/xf86glx.c b/GL/mesa/X/xf86glx.c index 5dd4e7c37..b185a958a 100644 --- a/GL/mesa/X/xf86glx.c +++ b/GL/mesa/X/xf86glx.c @@ -37,12 +37,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include <dix-config.h> #endif +#include <string.h> #include <regionstr.h> #include <resource.h> #include <GL/gl.h> #include <GL/glxint.h> #include <GL/glxtokens.h> #include <scrnintstr.h> +#include <windowstr.h> #include <config.h> #include <glxserver.h> #include <glxscreens.h> @@ -50,12 +52,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include <glxcontext.h> #include <glxext.h> #include <glxutil.h> -#include "xf86glxint.h" #include "context.h" #include "xmesaP.h" #include <GL/xf86glx.h> #include "context.h" +#include "glcontextmodes.h" +#include "os.h" + /* * This define is for the glcore.h header file. * If you add it here, then make sure you also add it in @@ -69,489 +73,265 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include <GL/internal/glcore.h> #endif -#include "glcontextmodes.h" +typedef struct __GLXMESAscreen __GLXMESAscreen; +typedef struct __GLXMESAcontext __GLXMESAcontext; +typedef struct __GLXMESAdrawable __GLXMESAdrawable; -/* - * This structure is statically allocated in the __glXScreens[] - * structure. This struct is not used anywhere other than in - * __glXScreenInit to initialize each of the active screens - * (__glXActiveScreens[]). Several of the fields must be initialized by - * the screenProbe routine before they are copied to the active screens - * struct. In particular, the contextCreate, pGlxVisual, numVisuals, - * and numUsableVisuals fields must be initialized. - */ -static __GLXscreenInfo __glDDXScreenInfo = { - __MESA_screenProbe, /* Must be generic and handle all screens */ - __MESA_createContext, /* Substitute screen's createContext routine */ - __MESA_createBuffer, /* Substitute screen's createBuffer routine */ - NULL, /* Set up modes in probe */ - NULL, /* Set up pVisualPriv in probe */ - 0, /* Set up numVisuals in probe */ - 0, /* Set up numUsableVisuals in probe */ - NULL, /* GLextensions is overwritten by __glXScreenInit */ - "Vendor String", /* GLXvendor is overwritten by __glXScreenInit */ - "Version String", /* GLXversion is overwritten by __glXScreenInit */ - "Extensions String", /* GLXextensions is overwritten by __glXScreenInit */ - NULL /* WrappedPositionWindow is overwritten */ +struct __GLXMESAscreen { + __GLXscreen base; + int index; + XMesaVisual *xm_vis; }; -void *__glXglDDXScreenInfo(void) { - return &__glDDXScreenInfo; -} +struct __GLXMESAcontext { + __GLXcontext base; + XMesaContext xmesa; +}; -static __GLXextensionInfo __glDDXExtensionInfo = { - GL_CORE_MESA, - __MESA_resetExtension, - __MESA_initVisuals, - __MESA_setVisualConfigs +struct __GLXMESAdrawable { + __GLXdrawable base; + XMesaBuffer xm_buf; }; -void *__glXglDDXExtensionInfo(void) { - return &__glDDXExtensionInfo; -} +static XMesaVisual find_mesa_visual(__GLXscreen *screen, VisualID vid); -static __MESA_screen MESAScreens[MAXSCREENS]; -static __GLcontext *MESA_CC = NULL; -static int numConfigs = 0; -static __GLXvisualConfig *visualConfigs = NULL; -static void **visualPrivates = NULL; +static void +__glXMesaDrawableDestroy(__GLXdrawable *base) +{ + __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base; + XMesaDestroyBuffer(glxPriv->xm_buf); + xfree(glxPriv); +} -static int count_bits(unsigned int n) +static GLboolean +__glXMesaDrawableResize(__GLXdrawable *base) { - int bits = 0; + __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base; - while (n > 0) { - if (n & 1) bits++; - n >>= 1; - } - return bits; -} + XMesaResizeBuffers(glxPriv->xm_buf); + return GL_TRUE; +} -static XMesaVisual find_mesa_visual(int screen, VisualID vid) +static GLboolean +__glXMesaDrawableSwapBuffers(__GLXdrawable *base) { - __MESA_screen * const pMScr = &MESAScreens[screen]; - const __GLcontextModes *modes; - unsigned i = 0; + __GLXMESAdrawable *glxPriv = (__GLXMESAdrawable *) base; - for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) { - if ( modes->visualID == vid ) { - break; - } + /* This is terrifying: XMesaSwapBuffers() ends up calling CopyArea + * to do the buffer swap, but this assumes that the server holds + * the lock and has its context visible. If another screen uses a + * DRI driver, that will have installed the DRI enter/leave server + * functions, which lifts the lock during GLX dispatch. This is + * why we need to re-take the lock and swap in the server context + * before calling XMesaSwapBuffers() here. /me shakes head. */ - i++; - } + __glXenterServer(); - return (modes != NULL) ? pMScr->xm_vis[i] : NULL; -} + XMesaSwapBuffers(glxPriv->xm_buf); + __glXleaveServer(); -/* - * In the case the driver defines no GLX visuals we'll use these. - * Note that for TrueColor and DirectColor visuals, bufferSize is the - * sum of redSize, greenSize, blueSize and alphaSize, which may be larger - * than the nplanes/rootDepth of the server's X11 visuals - */ -#define NUM_FALLBACK_CONFIGS 5 -static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = { - /* [0] = RGB, double buffered, Z */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 0, /* rgba sizes */ - -1, -1, -1, 0, /* rgba masks */ - 0, 0, 0, 0, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 0, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [1] = RGB, double buffered, Z, stencil, accum */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 0, /* rgba sizes */ - -1, -1, -1, 0, /* rgba masks */ - 16, 16, 16, 0, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 8, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [2] = RGB+Alpha, double buffered, Z, stencil, accum */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 8, /* rgba sizes */ - -1, -1, -1, -1, /* rgba masks */ - 16, 16, 16, 16, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 8, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [3] = RGB+Alpha, single buffered, Z, stencil, accum */ - { - -1, /* vid */ - -1, /* class */ - True, /* rgba */ - -1, -1, -1, 8, /* rgba sizes */ - -1, -1, -1, -1, /* rgba masks */ - 16, 16, 16, 16, /* rgba accum sizes */ - False, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 8, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, - /* [4] = CI, double buffered, Z */ - { - -1, /* vid */ - -1, /* class */ - False, /* rgba? (false = color index) */ - -1, -1, -1, 0, /* rgba sizes */ - -1, -1, -1, 0, /* rgba masks */ - 0, 0, 0, 0, /* rgba accum sizes */ - True, /* doubleBuffer */ - False, /* stereo */ - -1, /* bufferSize */ - 16, /* depthSize */ - 0, /* stencilSize */ - 0, /* auxBuffers */ - 0, /* level */ - GLX_NONE, /* visualRating */ - GLX_NONE, /* transparentPixel */ - 0, 0, 0, 0, /* transparent rgba color (floats scaled to ints) */ - 0 /* transparentIndex */ - }, -}; + return GL_TRUE; +} -static Bool init_visuals(int *nvisualp, VisualPtr *visualp, - VisualID *defaultVisp, - int ndepth, DepthPtr pdepth, - int rootDepth) +static __GLXdrawable * +__glXMesaContextCreateDrawable(__GLXcontext *context, + DrawablePtr pDraw, + XID drawId) { - int numRGBconfigs; - int numCIconfigs; - int numVisuals = *nvisualp; - int numNewVisuals; - int numNewConfigs; - VisualPtr pVisual = *visualp; - VisualPtr pVisualNew = NULL; - VisualID *orig_vid = NULL; - __GLcontextModes *modes; - __GLXvisualConfig *pNewVisualConfigs = NULL; - void **glXVisualPriv; - void **pNewVisualPriv; - int found_default; - int i, j, k; - - if (numConfigs > 0) - numNewConfigs = numConfigs; - else - numNewConfigs = NUM_FALLBACK_CONFIGS; - - /* Alloc space for the list of new GLX visuals */ - pNewVisualConfigs = (__GLXvisualConfig *) - __glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig)); - if (!pNewVisualConfigs) { - return FALSE; - } + __GLXMESAdrawable *glxPriv; + __GLXscreen *pGlxScreen; + XMesaVisual xm_vis; - /* Alloc space for the list of new GLX visual privates */ - pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *)); - if (!pNewVisualPriv) { - __glXFree(pNewVisualConfigs); - return FALSE; - } + glxPriv = xalloc(sizeof *glxPriv); + if (glxPriv == NULL) + return NULL; - /* - ** If SetVisualConfigs was not called, then use default GLX - ** visual configs. - */ - if (numConfigs == 0) { - memcpy(pNewVisualConfigs, FallbackConfigs, - NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig)); - memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *)); - } - else { - /* copy driver's visual config info */ - for (i = 0; i < numConfigs; i++) { - pNewVisualConfigs[i] = visualConfigs[i]; - pNewVisualPriv[i] = visualPrivates[i]; - } - } + memset(glxPriv, 0, sizeof *glxPriv); - /* Count the number of RGB and CI visual configs */ - numRGBconfigs = 0; - numCIconfigs = 0; - for (i = 0; i < numNewConfigs; i++) { - if (pNewVisualConfigs[i].rgba) - numRGBconfigs++; - else - numCIconfigs++; + if (!__glXDrawableInit(&glxPriv->base, context, pDraw, drawId)) { + xfree(glxPriv); + return NULL; } - /* Count the total number of visuals to compute */ - numNewVisuals = 0; - for (i = 0; i < numVisuals; i++) { - numNewVisuals += - (pVisual[i].class == TrueColor || pVisual[i].class == DirectColor) - ? numRGBconfigs : numCIconfigs; - } + glxPriv->base.destroy = __glXMesaDrawableDestroy; + glxPriv->base.resize = __glXMesaDrawableResize; + glxPriv->base.swapBuffers = __glXMesaDrawableSwapBuffers; - /* Reset variables for use with the next screen/driver's visual configs */ - visualConfigs = NULL; - numConfigs = 0; + pGlxScreen = __glXActiveScreens[pDraw->pScreen->myNum]; - /* Alloc temp space for the list of orig VisualIDs for each new visual */ - orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID)); - if (!orig_vid) { - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; - } + if (glxPriv->base.type == DRAWABLE_WINDOW) { + VisualID vid = wVisual((WindowPtr)pDraw); - /* Alloc space for the list of glXVisuals */ - modes = _gl_context_modes_create(numNewVisuals, sizeof(__GLcontextModes)); - if (modes == NULL) { - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; + glxPriv->base.modes = _gl_context_modes_find_visual(pGlxScreen->modes, + vid); + } else { + glxPriv->base.modes = glxPriv->base.pGlxPixmap->modes; } - /* Alloc space for the list of glXVisualPrivates */ - glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *)); - if (!glXVisualPriv) { - _gl_context_modes_destroy( modes ); - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; + xm_vis = find_mesa_visual(pGlxScreen, glxPriv->base.modes->visualID); + if (xm_vis == NULL) { + ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", + glxPriv->base.modes->visualID); + xfree(glxPriv); + return NULL; } - /* Alloc space for the new list of the X server's visuals */ - pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec)); - if (!pVisualNew) { - __glXFree(glXVisualPriv); - _gl_context_modes_destroy( modes ); - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); - return FALSE; + if (glxPriv->base.type == DRAWABLE_WINDOW) { + glxPriv->xm_buf = XMesaCreateWindowBuffer(xm_vis, (WindowPtr)pDraw); + } else { + glxPriv->xm_buf = XMesaCreatePixmapBuffer(xm_vis, (PixmapPtr)pDraw, 0); } - /* Initialize the new visuals */ - found_default = FALSE; - MESAScreens[screenInfo.numScreens-1].modes = modes; - for (i = j = 0; i < numVisuals; i++) { - int is_rgb = (pVisual[i].class == TrueColor || - pVisual[i].class == DirectColor); - - for (k = 0; k < numNewConfigs; k++) { - if (pNewVisualConfigs[k].rgba != is_rgb) - continue; - - assert( modes != NULL ); + return &glxPriv->base; +} - /* Initialize the new visual */ - pVisualNew[j] = pVisual[i]; - pVisualNew[j].vid = FakeClientID(0); +static void +__glXMesaContextDestroy(__GLXcontext *baseContext) +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; - /* Check for the default visual */ - if (!found_default && pVisual[i].vid == *defaultVisp) { - *defaultVisp = pVisualNew[j].vid; - found_default = TRUE; - } + XMesaDestroyContext(context->xmesa); + xfree(context); +} - /* Save the old VisualID */ - orig_vid[j] = pVisual[i].vid; - - /* Initialize the glXVisual */ - _gl_copy_visual_to_context_mode( modes, & pNewVisualConfigs[k] ); - modes->visualID = pVisualNew[j].vid; - - /* - * If the class is -1, then assume the X visual information - * is identical to what GLX needs, and take them from the X - * visual. NOTE: if class != -1, then all other fields MUST - * be initialized. - */ - if (modes->visualType == GLX_NONE) { - modes->visualType = _gl_convert_from_x_visual_type( pVisual[i].class ); - modes->redBits = count_bits(pVisual[i].redMask); - modes->greenBits = count_bits(pVisual[i].greenMask); - modes->blueBits = count_bits(pVisual[i].blueMask); - modes->alphaBits = modes->alphaBits; - modes->redMask = pVisual[i].redMask; - modes->greenMask = pVisual[i].greenMask; - modes->blueMask = pVisual[i].blueMask; - modes->alphaMask = modes->alphaMask; - modes->rgbBits = (is_rgb) - ? (modes->redBits + modes->greenBits + - modes->blueBits + modes->alphaBits) - : rootDepth; - } +static int +__glXMesaContextMakeCurrent(__GLXcontext *baseContext) - /* Save the device-dependent private for this visual */ - glXVisualPriv[j] = pNewVisualPriv[k]; +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; + __GLXMESAdrawable *drawPriv = (__GLXMESAdrawable *) context->base.drawPriv; + __GLXMESAdrawable *readPriv = (__GLXMESAdrawable *) context->base.readPriv; - j++; - modes = modes->next; - } - } + return XMesaMakeCurrent2(context->xmesa, + drawPriv->xm_buf, + readPriv->xm_buf); +} - assert(j <= numNewVisuals); - - /* Save the GLX visuals in the screen structure */ - MESAScreens[screenInfo.numScreens-1].num_vis = numNewVisuals; - MESAScreens[screenInfo.numScreens-1].private = glXVisualPriv; - - /* Set up depth's VisualIDs */ - for (i = 0; i < ndepth; i++) { - int numVids = 0; - VisualID *pVids = NULL; - int k, n = 0; - - /* Count the new number of VisualIDs at this depth */ - for (j = 0; j < pdepth[i].numVids; j++) - for (k = 0; k < numNewVisuals; k++) - if (pdepth[i].vids[j] == orig_vid[k]) - numVids++; - - /* Allocate a new list of VisualIDs for this depth */ - pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID)); - - /* Initialize the new list of VisualIDs for this depth */ - for (j = 0; j < pdepth[i].numVids; j++) - for (k = 0; k < numNewVisuals; k++) - if (pdepth[i].vids[j] == orig_vid[k]) - pVids[n++] = pVisualNew[k].vid; - - /* Update this depth's list of VisualIDs */ - __glXFree(pdepth[i].vids); - pdepth[i].vids = pVids; - pdepth[i].numVids = numVids; - } +static int +__glXMesaContextLoseCurrent(__GLXcontext *baseContext) +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; - /* Update the X server's visuals */ - *nvisualp = numNewVisuals; - *visualp = pVisualNew; + return XMesaLoseCurrent(context->xmesa); +} - /* Free the old list of the X server's visuals */ - __glXFree(pVisual); +static int +__glXMesaContextCopy(__GLXcontext *baseDst, + __GLXcontext *baseSrc, + unsigned long mask) +{ + __GLXMESAcontext *dst = (__GLXMESAcontext *) baseDst; + __GLXMESAcontext *src = (__GLXMESAcontext *) baseSrc; - /* Clean up temporary allocations */ - __glXFree(orig_vid); - __glXFree(pNewVisualPriv); - __glXFree(pNewVisualConfigs); + _mesa_copy_context(&src->xmesa->mesa, &dst->xmesa->mesa, mask); + return GL_TRUE; +} - /* Free the private list created by DDX HW driver */ - if (visualPrivates) - xfree(visualPrivates); - visualPrivates = NULL; +static int +__glXMesaContextForceCurrent(__GLXcontext *baseContext) +{ + __GLXMESAcontext *context = (__GLXMESAcontext *) baseContext; - return TRUE; + return XMesaForceCurrent(context->xmesa); } -void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs, - void **privates) +static __GLXcontext * +__glXMesaScreenCreateContext(__GLXscreen *screen, + __GLcontextModes *modes, + __GLXcontext *baseShareContext) { - numConfigs = nconfigs; - visualConfigs = configs; - visualPrivates = privates; + __GLXMESAcontext *context; + __GLXMESAcontext *shareContext = (__GLXMESAcontext *) baseShareContext; + XMesaVisual xm_vis; + XMesaContext xm_share; + + context = xalloc (sizeof (__GLXMESAcontext)); + if (context == NULL) + return NULL; + + memset(context, 0, sizeof *context); + + context->base.pGlxScreen = screen; + context->base.modes = modes; + + context->base.destroy = __glXMesaContextDestroy; + context->base.makeCurrent = __glXMesaContextMakeCurrent; + context->base.loseCurrent = __glXMesaContextLoseCurrent; + context->base.copy = __glXMesaContextCopy; + context->base.forceCurrent = __glXMesaContextForceCurrent; + context->base.createDrawable = __glXMesaContextCreateDrawable; + + xm_vis = find_mesa_visual(screen, modes->visualID); + if (!xm_vis) { + ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", + modes->visualID); + xfree(context); + return NULL; + } + + xm_share = shareContext ? shareContext->xmesa : NULL; + context->xmesa = XMesaCreateContext(xm_vis, xm_share); + if (!context->xmesa) { + xfree(context); + return NULL; + } + + return &context->base; } -Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp, - int *nvisualp, int *ndepthp, int *rootDepthp, - VisualID *defaultVisp, unsigned long sizes, - int bitsPerRGB) +static void +__glXMesaScreenDestroy(__GLXscreen *screen) { - /* - * Setup the visuals supported by this particular screen. - */ - return init_visuals(nvisualp, visualp, defaultVisp, - *ndepthp, *depthp, *rootDepthp); + __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen; + int i; + + for (i = 0; i < screen->numVisuals; i++) { + if (mesaScreen->xm_vis[i]) + XMesaDestroyVisual(mesaScreen->xm_vis[i]); + } + + xfree(mesaScreen->xm_vis); + + __glXScreenDestroy(screen); + + xfree(screen); } -static void fixup_visuals(int screen) +static XMesaVisual +find_mesa_visual(__GLXscreen *screen, VisualID vid) { - ScreenPtr pScreen = screenInfo.screens[screen]; - __MESA_screen *pMScr = &MESAScreens[screen]; - int j; - __GLcontextModes *modes; - - for ( modes = pMScr->modes ; modes != NULL ; modes = modes->next ) { - const int vis_class = _gl_convert_to_x_visual_type( modes->visualType ); - const int nplanes = (modes->rgbBits - modes->alphaBits); - const VisualPtr pVis = pScreen->visuals; + __GLXMESAscreen *mesaScreen = (__GLXMESAscreen *) screen; + const __GLcontextModes *modes; + unsigned i = 0; - /* Find a visual that matches the GLX visual's class and size */ - for (j = 0; j < pScreen->numVisuals; j++) { - if (pVis[j].class == vis_class && - pVis[j].nplanes == nplanes) { - - /* Fixup the masks */ - modes->redMask = pVis[j].redMask; - modes->greenMask = pVis[j].greenMask; - modes->blueMask = pVis[j].blueMask; - - /* Recalc the sizes */ - modes->redBits = count_bits(modes->redMask); - modes->greenBits = count_bits(modes->greenMask); - modes->blueBits = count_bits(modes->blueMask); - } + for ( modes = screen->modes ; modes != NULL ; modes = modes->next ) { + if ( modes->visualID == vid ) { + break; } + + i++; } + + return (modes != NULL) ? mesaScreen->xm_vis[i] : NULL; } -static void init_screen_visuals(int screen) +static void init_screen_visuals(__GLXMESAscreen *screen) { - ScreenPtr pScreen = screenInfo.screens[screen]; + ScreenPtr pScreen = screen->base.pScreen; __GLcontextModes *modes; XMesaVisual *pXMesaVisual; int *used; - int i, j; + int i, j, size; /* Alloc space for the list of XMesa visuals */ - pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis * - sizeof(XMesaVisual)); - __glXMemset(pXMesaVisual, 0, - MESAScreens[screen].num_vis * sizeof(XMesaVisual)); + size = screen->base.numVisuals * sizeof(XMesaVisual); + pXMesaVisual = (XMesaVisual *) xalloc(size); + memset(pXMesaVisual, 0, size); /* FIXME: Change 'used' to be a array of bits (rather than of ints), * FIXME: create a stack array of 8 or 16 bytes. If 'numVisuals' is less @@ -559,13 +339,11 @@ static void init_screen_visuals(int screen) * FIXME: __glXMalloc / __glXFree. If nothing else, convert 'used' to * FIXME: array of bytes instead of ints! */ - used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int)); - __glXMemset(used, 0, pScreen->numVisuals * sizeof(int)); + used = (int *) xalloc(pScreen->numVisuals * sizeof(int)); + memset(used, 0, pScreen->numVisuals * sizeof(int)); i = 0; - for ( modes = MESAScreens[screen].modes - ; modes != NULL - ; modes = modes->next ) { + for ( modes = screen->base.modes; modes != NULL; modes = modes->next ) { const int vis_class = _gl_convert_to_x_visual_type( modes->visualType ); const int nplanes = (modes->rgbBits - modes->alphaBits); const VisualPtr pVis = pScreen->visuals; @@ -621,30 +399,23 @@ static void init_screen_visuals(int screen) __glXFree(used); - MESAScreens[screen].xm_vis = pXMesaVisual; + screen->xm_vis = pXMesaVisual; } -Bool __MESA_screenProbe(int screen) +static __GLXscreen * +__glXMesaScreenProbe(ScreenPtr pScreen) { - /* - * Set up the current screen's visuals. - */ - __glDDXScreenInfo.modes = MESAScreens[screen].modes; - __glDDXScreenInfo.pVisualPriv = MESAScreens[screen].private; - __glDDXScreenInfo.numVisuals = - __glDDXScreenInfo.numUsableVisuals = MESAScreens[screen].num_vis; + __GLXMESAscreen *screen; - /* - * Set the current screen's createContext routine. This could be - * wrapped by a DDX GLX context creation routine. - */ - __glDDXScreenInfo.createContext = __MESA_createContext; + screen = xalloc(sizeof *screen); + if (screen == NULL) + return NULL; - /* - * The ordering of the rgb compenents might have been changed by the - * driver after mi initialized them. - */ - fixup_visuals(screen); + __glXScreenInit(&screen->base, pScreen); + + screen->base.destroy = __glXMesaScreenDestroy; + screen->base.createContext = __glXMesaScreenCreateContext; + screen->base.pScreen = pScreen; /* * Find the GLX visuals that are supported by this screen and create @@ -652,263 +423,11 @@ Bool __MESA_screenProbe(int screen) */ init_screen_visuals(screen); - return TRUE; -} - -extern void __MESA_resetExtension(void) -{ - int i, j; - - XMesaReset(); - - for (i = 0; i < screenInfo.numScreens; i++) { - for (j = 0; j < MESAScreens[i].num_vis; j++) { - if (MESAScreens[i].xm_vis[j]) { - XMesaDestroyVisual(MESAScreens[i].xm_vis[j]); - MESAScreens[i].xm_vis[j] = NULL; - } - } - _gl_context_modes_destroy( MESAScreens[i].modes ); - MESAScreens[i].modes = NULL; - __glXFree(MESAScreens[i].private); - MESAScreens[i].private = NULL; - __glXFree(MESAScreens[i].xm_vis); - MESAScreens[i].xm_vis = NULL; - MESAScreens[i].num_vis = 0; - } - __glDDXScreenInfo.modes = NULL; - MESA_CC = NULL; -} - -void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv) -{ - DrawablePtr pDraw = glxPriv->pDraw; - XMesaVisual xm_vis = find_mesa_visual(pDraw->pScreen->myNum, - glxPriv->modes->visualID); - __GLdrawablePrivate *glPriv = &glxPriv->glPriv; - __MESA_buffer buf; - - if (xm_vis == NULL) { - ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", - glxPriv->modes->visualID); - } - buf = (__MESA_buffer)__glXMalloc(sizeof(struct __MESA_bufferRec)); - - /* Create Mesa's buffers */ - if (glxPriv->type == DRAWABLE_WINDOW) { - buf->xm_buf = (void *)XMesaCreateWindowBuffer(xm_vis, - (WindowPtr)pDraw); - } else { - buf->xm_buf = (void *)XMesaCreatePixmapBuffer(xm_vis, - (PixmapPtr)pDraw, 0); - } - - /* Wrap the front buffer's resize routine */ - buf->fbresize = glPriv->frontBuffer.resize; - glPriv->frontBuffer.resize = __MESA_resizeBuffers; - - /* Wrap the swap buffers routine */ - buf->fbswap = glxPriv->swapBuffers; - glxPriv->swapBuffers = __MESA_swapBuffers; - - /* Save Mesa's private buffer structure */ - glPriv->private = (void *)buf; - glPriv->freePrivate = __MESA_destroyBuffer; -} - -GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buffer, - GLint x, GLint y, - GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, - GLuint bufferMask) -{ - __MESA_buffer buf = (__MESA_buffer)glPriv->private; - - if (buf->xm_buf) - XMesaResizeBuffers(buf->xm_buf); - - return (*buf->fbresize)(buffer, x, y, width, height, glPriv, bufferMask); -} - -GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv) -{ - __MESA_buffer buf = (__MESA_buffer)glxPriv->glPriv.private; - - /* - ** Do not call the wrapped swap buffers routine since Mesa has - ** already done the swap. - */ - XMesaSwapBuffers(buf->xm_buf); - - return GL_TRUE; -} - -void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv) -{ - __MESA_buffer buf = (__MESA_buffer)glPriv->private; - __GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other; - - /* Destroy Mesa's buffers */ - if (buf->xm_buf) - XMesaDestroyBuffer(buf->xm_buf); - - /* Unwrap these routines */ - glxPriv->swapBuffers = buf->fbswap; - glPriv->frontBuffer.resize = buf->fbresize; - - __glXFree(glPriv->private); - glPriv->private = NULL; -} - -__GLinterface *__MESA_createContext(__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC) -{ - __GLcontext *gl_ctx = NULL; - __GLcontext *m_share = NULL; - __GLXcontext *glxc = (__GLXcontext *)imports->other; - XMesaVisual xm_vis; - - if (shareGC) - m_share = (__GLcontext *)shareGC; - - xm_vis = find_mesa_visual(glxc->pScreen->myNum, glxc->modes->visualID); - if (xm_vis) { - XMesaContext xmshare = m_share ? m_share->DriverCtx : 0; - XMesaContext xmctx = XMesaCreateContext(xm_vis, xmshare); - gl_ctx = xmctx ? &xmctx->mesa : 0; - } - else { - ErrorF("find_mesa_visual returned NULL for visualID = 0x%04x\n", - glxc->modes->visualID); - } - - - if (!gl_ctx) - return NULL; - - gl_ctx->imports = *imports; - gl_ctx->exports.destroyContext = __MESA_destroyContext; - gl_ctx->exports.loseCurrent = __MESA_loseCurrent; - gl_ctx->exports.makeCurrent = __MESA_makeCurrent; - gl_ctx->exports.shareContext = __MESA_shareContext; - gl_ctx->exports.copyContext = __MESA_copyContext; - gl_ctx->exports.forceCurrent = __MESA_forceCurrent; - gl_ctx->exports.notifyResize = __MESA_notifyResize; - gl_ctx->exports.notifyDestroy = __MESA_notifyDestroy; - gl_ctx->exports.notifySwapBuffers = __MESA_notifySwapBuffers; - gl_ctx->exports.dispatchExec = __MESA_dispatchExec; - gl_ctx->exports.beginDispatchOverride = __MESA_beginDispatchOverride; - gl_ctx->exports.endDispatchOverride = __MESA_endDispatchOverride; - - return (__GLinterface *)gl_ctx; -} - -GLboolean __MESA_destroyContext(__GLcontext *gc) -{ - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - XMesaDestroyContext( xmesa ); - return GL_TRUE; -} - -GLboolean __MESA_loseCurrent(__GLcontext *gc) -{ - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - MESA_CC = NULL; - __glXLastContext = NULL; - return XMesaLoseCurrent(xmesa); -} - -GLboolean __MESA_makeCurrent(__GLcontext *gc) -{ - __GLdrawablePrivate *drawPriv = gc->imports.getDrawablePrivate( gc ); - __MESA_buffer drawBuf = (__MESA_buffer)drawPriv->private; - __GLdrawablePrivate *readPriv = gc->imports.getReadablePrivate( gc ); - __MESA_buffer readBuf = (__MESA_buffer)readPriv->private; - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - - MESA_CC = gc; - return XMesaMakeCurrent2(xmesa, drawBuf->xm_buf, readBuf->xm_buf); -} - -GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare) -{ - /* NOT_DONE */ - /* XXX I don't see where/how this could ever be called */ - ErrorF("__MESA_shareContext\n"); - return GL_FALSE; -} - -GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src, - GLuint mask) -{ - XMesaContext xm_dst = (XMesaContext) dst->DriverCtx; - const XMesaContext xm_src = (const XMesaContext) src->DriverCtx; - _mesa_copy_context(&xm_src->mesa, &xm_dst->mesa, mask); - return GL_TRUE; -} - -GLboolean __MESA_forceCurrent(__GLcontext *gc) -{ - XMesaContext xmesa = (XMesaContext) gc->DriverCtx; - MESA_CC = gc; - return XMesaForceCurrent(xmesa); -} - -GLboolean __MESA_notifyResize(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_notifyResize\n"); - return GL_FALSE; -} - -void __MESA_notifyDestroy(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_notifyDestroy\n"); - return; -} - -void __MESA_notifySwapBuffers(__GLcontext *gc) -{ - _mesa_notifySwapBuffers(gc); -} - -struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_dispatchExec\n"); - return NULL; -} - -void __MESA_beginDispatchOverride(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_beginDispatchOverride\n"); - return; -} - -void __MESA_endDispatchOverride(__GLcontext *gc) -{ - /* NOT_DONE */ - ErrorF("__MESA_endDispatchOverride\n"); - return; -} - - -/* - * Server-side GLX uses these functions which are normally defined - * in the OpenGL SI. - */ - -GLuint __glFloorLog2(GLuint val) -{ - int c = 0; - - while (val > 1) { - c++; - val >>= 1; - } - return c; + return &screen->base; } +__GLXprovider __glXMesaProvider = { + __glXMesaScreenProbe, + "MESA", + NULL +}; diff --git a/GL/mesa/X/xf86glxint.h b/GL/mesa/X/xf86glxint.h index 974ff0364..4e51215bc 100644 --- a/GL/mesa/X/xf86glxint.h +++ b/GL/mesa/X/xf86glxint.h @@ -43,60 +43,4 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include <GL/gl.h> #include <GL/xmesa.h> -typedef struct __MESA_screenRec __MESA_screen; -struct __MESA_screenRec { - int num_vis; - __GLcontextModes *modes; - XMesaVisual *xm_vis; - void **private; -}; - -typedef struct __MESA_bufferRec *__MESA_buffer; -struct __MESA_bufferRec { - XMesaBuffer xm_buf; - GLboolean (*fbresize)(__GLdrawableBuffer *buf, - GLint x, GLint y, GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, GLuint bufferMask); - GLboolean (*fbswap)(__GLXdrawablePrivate *glxPriv); -}; - -extern void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs, - void **privates); -extern Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp, - int *nvisualp, int *ndepthp, int *rootDepthp, - VisualID *defaultVisp, unsigned long sizes, - int bitsPerRGB); -extern Bool __MESA_screenProbe(int screen); - -extern void __MESA_resetExtension(void); - -extern void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv); -extern GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buf, - GLint x, GLint y, - GLuint width, GLuint height, - __GLdrawablePrivate *glPriv, - GLuint bufferMask); -extern GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv); -extern void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv); - -extern __GLinterface *__MESA_createContext(__GLimports *imports, - __GLcontextModes *modes, - __GLinterface *shareGC); -extern GLboolean __MESA_destroyContext(__GLcontext *gc); -extern GLboolean __MESA_loseCurrent(__GLcontext *gc); -extern GLboolean __MESA_makeCurrent(__GLcontext *gc); -extern GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare); -extern GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src, - GLuint mask); -extern GLboolean __MESA_forceCurrent(__GLcontext *gc); - -extern GLboolean __MESA_notifyResize(__GLcontext *gc); -extern void __MESA_notifyDestroy(__GLcontext *gc); -extern void __MESA_notifySwapBuffers(__GLcontext *gc); -extern struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc); -extern void __MESA_beginDispatchOverride(__GLcontext *gc); -extern void __MESA_endDispatchOverride(__GLcontext *gc); - -extern GLuint __glFloorLog2(GLuint val); - #endif /* _XF86GLXINT_H_ */ diff --git a/GL/mesa/swrast/Makefile.am b/GL/mesa/swrast/Makefile.am index 5a0ed9cd3..973de3ac2 100644 --- a/GL/mesa/swrast/Makefile.am +++ b/GL/mesa/swrast/Makefile.am @@ -10,6 +10,7 @@ INCLUDES = -I@MESA_SOURCE@/include \ -I../math \ -I../shader \ -I../shader/slang \ + -I../shader/slang \ -I../swrast \ -I../swrast_setup \ -I../tnl \ diff --git a/GL/symlink-mesa.sh b/GL/symlink-mesa.sh index fa14f629d..afd1f5501 100755 --- a/GL/symlink-mesa.sh +++ b/GL/symlink-mesa.sh @@ -63,6 +63,7 @@ symlink_mesa_glapi() { dst_dir mesa/glapi action dispatch.h + action glapi.c action glapi.h action glapioffsets.h action glapitable.h diff --git a/configure.ac b/configure.ac index a8971dbbe..1cedcfa55 100644 --- a/configure.ac +++ b/configure.ac @@ -362,6 +362,9 @@ AC_ARG_WITH(xkb-output, AS_HELP_STRING([--with-xkb-output=PATH], [Path to AC_ARG_WITH(rgb-path, AS_HELP_STRING([--with-rgb-path=PATH], [Path to RGB database (default: ${datadir}/X11/rgb)]), [ RGBPATH="$withval" ], [ RGBPATH="${datadir}/X11/rgb" ]) +AC_ARG_WITH(dri-driver-path, AS_HELP_STRING([--with-dri-driver-path=PATH], [Path to DRI drivers (default: ${libdir}/dri)]), + [ DRI_DRIVER_PATH="$withval" ], + [ DRI_DRIVER_PATH="${libdir}/dri" ]) AC_ARG_ENABLE(builddocs, AS_HELP_STRING([--enable-builddocs], [Build docs (default: disabled)]), [BUILDDOCS=$enableval], [BUILDDOCS=no]) @@ -384,6 +387,7 @@ AC_ARG_ENABLE(screensaver, AS_HELP_STRING([--disable-screensaver], [Build Scr AC_ARG_ENABLE(xdmcp, AS_HELP_STRING([--disable-xdmcp], [Build XDMCP extension (default: auto)]), [XDMCP=$enableval], [XDMCP=auto]) AC_ARG_ENABLE(xdm-auth-1, AS_HELP_STRING([--disable-xdm-auth-1], [Build XDM-Auth-1 extension (default: auto)]), [XDMAUTH=$enableval], [XDMAUTH=auto]) AC_ARG_ENABLE(glx, AS_HELP_STRING([--disable-glx], [Build GLX extension (default: enabled)]), [GLX=$enableval], [GLX=yes]) +AC_ARG_ENABLE(aiglx, AS_HELP_STRING([--enable-aiglx], [Build accelerated indirect GLX (default: enabled)]), [AIGLX=$enableval], [AIGLX=yes]) AC_ARG_ENABLE(dri, AS_HELP_STRING([--enable-dri], [Build DRI extension (default: auto)]), [DRI=$enableval]) AC_ARG_ENABLE(xinerama, AS_HELP_STRING([--disable-xinerama], [Build Xinerama extension (default: enabled)]), [XINERAMA=$enableval], [XINERAMA=yes]) AC_ARG_ENABLE(xf86vidmode, AS_HELP_STRING([--disable-xf86vidmode], [Build XF86VidMode extension (default: enabled)]), [XF86VIDMODE=$enableval], [XF86VIDMODE=yes]) @@ -559,6 +563,13 @@ fi AM_CONDITIONAL(GLX, test "x$GLX" = xyes) AC_SUBST([MESA_SOURCE]) +if test "x$AIGLX" = xyes -a "x$GLX" = xyes -a "x$DRI" = xyes; then + AC_DEFINE(AIGLX, 1, [Build AIGLX loader]) +else + AIGLX=no +fi +AM_CONDITIONAL(AIGLX, test "x$AIGLX" = xyes) + PKG_CHECK_MODULES([LBXUTIL_TEST], [lbxutil], [have_lbxutil=yes], [have_lbxutil=no]) if test "x$LBX" = xauto; then @@ -768,6 +779,7 @@ VENDOR_MAN_VERSION="Version ${VENDOR_VERSION_STRING}" AC_DEFINE_DIR(COMPILEDDEFAULTFONTPATH, FONTPATH, [Default font path]) AC_DEFINE_DIR(RGB_DB, RGBPATH, [Default RGB path]) +AC_DEFINE_DIR(DRI_DRIVER_PATH, DRI_DRIVER_PATH, [Default DRI driver path]) AC_DEFINE_UNQUOTED(XVENDORNAME, ["$VENDOR_STRING"], [Vendor name]) AC_DEFINE_UNQUOTED(XVENDORNAMESHORT, ["$VENDOR_STRING_SHORT"], [Short vendor name]) AC_DEFINE_UNQUOTED(XORG_RELEASE, ["$VENDOR_RELEASE_STRING"], [Vendor release]) diff --git a/hw/dmx/glxProxy/glxext.c b/hw/dmx/glxProxy/glxext.c index 60338230e..5ddfbe608 100644 --- a/hw/dmx/glxProxy/glxext.c +++ b/hw/dmx/glxProxy/glxext.c @@ -37,6 +37,13 @@ #include "glxswap.h" /* +** Stubs to satisfy miinitext.c references. +*/ +typedef int __GLXprovider; +__GLXprovider __glXMesaProvider; +void GlxPushProvider(__GLXprovider *provider) { } + +/* ** Forward declarations. */ static int __glXSwapDispatch(ClientPtr); diff --git a/hw/xfree86/common/xf86Config.c b/hw/xfree86/common/xf86Config.c index aded9132d..448f85594 100644 --- a/hw/xfree86/common/xf86Config.c +++ b/hw/xfree86/common/xf86Config.c @@ -1,4 +1,4 @@ -/* $XdotOrg: xserver/xorg/hw/xfree86/common/xf86Config.c,v 1.21 2005/12/20 21:34:21 ajax Exp $ */ +/* $XdotOrg: xserver/xorg/hw/xfree86/common/xf86Config.c,v 1.22.8.2 2006/02/28 23:55:03 krh Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/common/xf86Config.c,v 3.276 2003/10/08 14:58:26 dawes Exp $ */ @@ -756,7 +756,8 @@ typedef enum { FLAG_LOG, FLAG_RENDER_COLORMAP_MODE, FLAG_HANDLE_SPECIAL_KEYS, - FLAG_RANDR + FLAG_RANDR, + FLAG_AIGLX } FlagValues; static OptionInfoRec FlagOptions[] = { @@ -826,6 +827,8 @@ static OptionInfoRec FlagOptions[] = { {0}, FALSE }, { FLAG_RANDR, "RandR", OPTV_BOOLEAN, {0}, FALSE }, + { FLAG_AIGLX, "AIGLX", OPTV_BOOLEAN, + {0}, FALSE }, { -1, NULL, OPTV_NONE, {0}, FALSE }, }; @@ -1010,6 +1013,13 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts) else xf86Info.estimateSizesAggressively = 0; + xf86Info.aiglx = TRUE; + xf86Info.aiglxFrom = X_DEFAULT; + if (xf86GetOptValBool(FlagOptions, FLAG_AIGLX, &value)) { + xf86Info.aiglx = value; + xf86Info.aiglxFrom = X_CONFIG; + } + /* Make sure that timers don't overflow CARD32's after multiplying */ #define MAX_TIME_IN_MIN (0x7fffffff / MILLI_PER_MIN) diff --git a/hw/xfree86/common/xf86Module.h b/hw/xfree86/common/xf86Module.h index 84c3e32c3..ea6d25b09 100644 --- a/hw/xfree86/common/xf86Module.h +++ b/hw/xfree86/common/xf86Module.h @@ -196,11 +196,15 @@ extern ExtensionModule *ExtensionModuleList; pointer LoadSubModule(pointer, const char *, const char **, const char **, pointer, const XF86ModReqInfo *, int *, int *); +pointer LoadSubModuleLocal(pointer, const char *, const char **, + const char **, pointer, const XF86ModReqInfo *, + int *, int *); void UnloadSubModule(pointer); void LoadFont(pointer); void UnloadModule (pointer); #endif pointer LoaderSymbol(const char *); +pointer LoaderSymbolLocal(pointer module, const char *); char **LoaderListDirs(const char **, const char **); void LoaderFreeDirList(char **); void LoaderErrorMsg(const char *, const char *, int, int); diff --git a/hw/xfree86/common/xf86Privstr.h b/hw/xfree86/common/xf86Privstr.h index 2f15e14cb..a35de2065 100644 --- a/hw/xfree86/common/xf86Privstr.h +++ b/hw/xfree86/common/xf86Privstr.h @@ -165,6 +165,8 @@ typedef struct { Bool kbdCustomKeycodes; Bool disableRandR; MessageType randRFrom; + Bool aiglx; + MessageType aiglxFrom; struct { Bool disabled; /* enable/disable deactivating * grabs or closing the diff --git a/hw/xfree86/dixmods/Makefile.am b/hw/xfree86/dixmods/Makefile.am index 6b744d727..0e06f5464 100644 --- a/hw/xfree86/dixmods/Makefile.am +++ b/hw/xfree86/dixmods/Makefile.am @@ -36,7 +36,8 @@ INCLUDES = @XORG_INCS@ \ -I$(top_srcdir)/mfb \ -I$(top_srcdir)/dbe \ -I$(top_srcdir)/hw/xfree86/loader \ - -I$(top_srcdir)/miext/shadow + -I$(top_srcdir)/miext/shadow \ + -I$(top_srcdir)/GL/glx libGLcore_la_LDFLAGS = -avoid-version libGLcore_la_LIBADD = $(top_builddir)/GL/mesa/libGLcore.la @@ -72,7 +73,9 @@ libfb_la_LIBADD = $(top_builddir)/fb/libfb.la libfb_la_SOURCES = $(top_builddir)/fb/fbcmap.c fbmodule.c libglx_la_LDFLAGS = -avoid-version -libglx_la_LIBADD = $(top_builddir)/GL/glx/libglx.la +libglx_la_LIBADD = \ + $(top_builddir)/GL/glx/libglx.la \ + $(top_builddir)/GL/glx/libglxdri.la libglx_la_SOURCES = glxmodule.c libmfb_la_LDFLAGS = -avoid-version diff --git a/hw/xfree86/dixmods/glxmodule.c b/hw/xfree86/dixmods/glxmodule.c index f8c03913e..9869b0295 100644 --- a/hw/xfree86/dixmods/glxmodule.c +++ b/hw/xfree86/dixmods/glxmodule.c @@ -37,15 +37,25 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #endif #include "xf86Module.h" +#include "xf86Priv.h" +#include "xf86.h" #include "colormap.h" #include "micmap.h" #include "globals.h" -static MODULESETUPPROTO(glxSetup); +typedef struct __GLXscreen __GLXscreen; +typedef struct __GLXprovider __GLXprovider; +struct __GLXprovider { + __GLXscreen *(*screenProbe)(ScreenPtr pScreen); + const char *name; + __GLXprovider *next; +}; -extern void GlxExtensionInit(INITARGS); +extern void GlxPushProvider(__GLXprovider *provider); +extern void GlxExtensionInit(void); extern void GlxWrapInitVisuals(miInitVisualsProcPtr *); -extern void InitGlxWrapInitVisuals(void (*f)(miInitVisualsProcPtr *)); + +static MODULESETUPPROTO(glxSetup); static const char *initdeps[] = { "DOUBLE-BUFFER", NULL }; @@ -58,1168 +68,6 @@ ExtensionModule GLXExt = initdeps }; -static const char *glcoreSymbols[] = { - "__glCallLists_size", - "__glColorTableParameterfv_size", - "__glColorTableParameteriv_size", - "__glConvolutionParameterfv_size", - "__glConvolutionParameteriv_size", - "__glDDXExtensionInfo", - "__glDDXScreenInfo", - "__glFloorLog2", - "__glFogfv_size", - "__glFogiv_size", - "__glGetBooleanv_size", - "__glGetColorTableParameterfv_size", - "__glGetColorTableParameteriv_size", - "__glGetConvolutionParameterfv_size", - "__glGetConvolutionParameteriv_size", - "__glGetDoublev_size", - "__glGetFloatv_size", - "__glGetHistogramParameterfv_size", - "__glGetHistogramParameteriv_size", - "__glGetIntegerv_size", - "__glGetLightfv_size", - "__glGetLightiv_size", - "__glGetMapdv_size", - "__glGetMapfv_size", - "__glGetMapiv_size", - "__glGetMaterialfv_size", - "__glGetMaterialiv_size", - "__glGetMinmaxParameterfv_size", - "__glGetMinmaxParameteriv_size", - "__glGetPixelMapfv_size", - "__glGetPixelMapuiv_size", - "__glGetPixelMapusv_size", - "__glGetTexEnvfv_size", - "__glGetTexEnviv_size", - "__glGetTexGendv_size", - "__glGetTexGenfv_size", - "__glGetTexGeniv_size", - "__glGetTexImage_size", - "__glGetTexLevelParameterfv_size", - "__glGetTexLevelParameteriv_size", - "__glGetTexParameterfv_size", - "__glGetTexParameteriv_size", - "__glLightModelfv_size", - "__glLightModeliv_size", - "__glLightfv_size", - "__glLightiv_size", - "__glMaterialfv_size", - "__glMaterialiv_size", - "__glPointParameterfvARB_size", - "__glReadPixels_size", - "__glTexEnvfv_size", - "__glTexEnviv_size", - "__glTexGendv_size", - "__glTexGenfv_size", - "__glTexGeniv_size", - "__glTexParameterfv_size", - "__glTexParameteriv_size", - "__glXglDDXExtensionInfo", - "__glXglDDXScreenInfo", - "__glXActiveScreens", - "__glXAssociateContext", - "__glXBadContext", - "__glXBadContextState", - "__glXBadContextTag", - "__glXBadCurrentWindow", - "__glXBadDrawable", - "__glXBadLargeRequest", - "__glXBadPixmap", - "__glXBadRenderRequest", - "__glXBitmapReqSize", - "__glXCacheDrawableSize", - "__glXCallListsReqSize", - "__glXClearErrorOccured", - "__glXClientInfo", - "__glXClientRes", - "__glXClients", - "__glXColorSubTableReqSize", - "__glXColorTableParameterfvReqSize", - "__glXColorTableParameterivReqSize", - "__glXColorTableReqSize", - "__glXContextRes", - "__glXConvolutionFilter1DReqSize", - "__glXConvolutionFilter2DReqSize", - "__glXConvolutionParameterfvReqSize", - "__glXConvolutionParameterivReqSize", - "__glXCopyContext", - "__glXCoreType", - "__glXCreateContext", - "__glXCreateGLXPixmap", - "__glXDeassociateContext", - "__glXDestroyContext", - "__glXDestroyGLXPixmap", - "__glXDispSwap_Accum", - "__glXDispSwap_ActiveStencilFaceEXT", - "__glXDispSwap_ActiveTextureARB", - "__glXDispSwap_AlphaFunc", - "__glXDispSwap_AreTexturesResident", - "__glXDispSwap_AreTexturesResidentEXT", - "__glXDispSwap_Begin", - "__glXDispSwap_BindTexture", - "__glXDispSwap_Bitmap", - "__glXDispSwap_BlendColor", - "__glXDispSwap_BlendEquation", - "__glXDispSwap_BlendFunc", - "__glXDispSwap_CallList", - "__glXDispSwap_CallLists", - "__glXDispSwap_Clear", - "__glXDispSwap_ClearAccum", - "__glXDispSwap_ClearColor", - "__glXDispSwap_ClearDepth", - "__glXDispSwap_ClearIndex", - "__glXDispSwap_ClearStencil", - "__glXDispSwap_ClipPlane", - "__glXDispSwap_Color3bv", - "__glXDispSwap_Color3dv", - "__glXDispSwap_Color3fv", - "__glXDispSwap_Color3iv", - "__glXDispSwap_Color3sv", - "__glXDispSwap_Color3ubv", - "__glXDispSwap_Color3uiv", - "__glXDispSwap_Color3usv", - "__glXDispSwap_Color4bv", - "__glXDispSwap_Color4dv", - "__glXDispSwap_Color4fv", - "__glXDispSwap_Color4iv", - "__glXDispSwap_Color4sv", - "__glXDispSwap_Color4ubv", - "__glXDispSwap_Color4uiv", - "__glXDispSwap_Color4usv", - "__glXDispSwap_ColorMask", - "__glXDispSwap_ColorMaterial", - "__glXDispSwap_ColorSubTable", - "__glXDispSwap_ColorTable", - "__glXDispSwap_ColorTableParameterfv", - "__glXDispSwap_ColorTableParameteriv", - "__glXDispSwap_ConvolutionFilter1D", - "__glXDispSwap_ConvolutionFilter2D", - "__glXDispSwap_ConvolutionParameterf", - "__glXDispSwap_ConvolutionParameterfv", - "__glXDispSwap_ConvolutionParameteri", - "__glXDispSwap_ConvolutionParameteriv", - "__glXDispSwap_CopyColorSubTable", - "__glXDispSwap_CopyColorTable", - "__glXDispSwap_CopyConvolutionFilter1D", - "__glXDispSwap_CopyConvolutionFilter2D", - "__glXDispSwap_CopyPixels", - "__glXDispSwap_CopyTexImage1D", - "__glXDispSwap_CopyTexImage2D", - "__glXDispSwap_CopyTexSubImage1D", - "__glXDispSwap_CopyTexSubImage2D", - "__glXDispSwap_CopyTexSubImage3D", - "__glXDispSwap_CullFace", - "__glXDispSwap_DeleteLists", - "__glXDispSwap_DeleteTextures", - "__glXDispSwap_DeleteTexturesEXT", - "__glXDispSwap_DepthFunc", - "__glXDispSwap_DepthMask", - "__glXDispSwap_DepthRange", - "__glXDispSwap_Disable", - "__glXDispSwap_DrawArrays", - "__glXDispSwap_DrawArraysEXT", - "__glXDispSwap_DrawBuffer", - "__glXDispSwap_DrawPixels", - "__glXDispSwap_EdgeFlagv", - "__glXDispSwap_Enable", - "__glXDispSwap_End", - "__glXDispSwap_EndList", - "__glXDispSwap_EvalCoord1dv", - "__glXDispSwap_EvalCoord1fv", - "__glXDispSwap_EvalCoord2dv", - "__glXDispSwap_EvalCoord2fv", - "__glXDispSwap_EvalMesh1", - "__glXDispSwap_EvalMesh2", - "__glXDispSwap_EvalPoint1", - "__glXDispSwap_EvalPoint2", - "__glXDispSwap_FeedbackBuffer", - "__glXDispSwap_Finish", - "__glXDispSwap_Flush", - "__glXDispSwap_Fogf", - "__glXDispSwap_Fogfv", - "__glXDispSwap_Fogi", - "__glXDispSwap_Fogiv", - "__glXDispSwap_FrontFace", - "__glXDispSwap_Frustum", - "__glXDispSwap_GenLists", - "__glXDispSwap_GenTextures", - "__glXDispSwap_GenTexturesEXT", - "__glXDispSwap_GetBooleanv", - "__glXDispSwap_GetClipPlane", - "__glXDispSwap_GetColorTable", - "__glXDispSwap_GetColorTableParameterfv", - "__glXDispSwap_GetColorTableParameteriv", - "__glXDispSwap_GetConvolutionFilter", - "__glXDispSwap_GetConvolutionParameterfv", - "__glXDispSwap_GetConvolutionParameteriv", - "__glXDispSwap_GetDoublev", - "__glXDispSwap_GetError", - "__glXDispSwap_GetFloatv", - "__glXDispSwap_GetHistogram", - "__glXDispSwap_GetHistogramParameterfv", - "__glXDispSwap_GetHistogramParameteriv", - "__glXDispSwap_GetIntegerv", - "__glXDispSwap_GetLightfv", - "__glXDispSwap_GetLightiv", - "__glXDispSwap_GetMapdv", - "__glXDispSwap_GetMapfv", - "__glXDispSwap_GetMapiv", - "__glXDispSwap_GetMaterialfv", - "__glXDispSwap_GetMaterialiv", - "__glXDispSwap_GetMinmax", - "__glXDispSwap_GetMinmaxParameterfv", - "__glXDispSwap_GetMinmaxParameteriv", - "__glXDispSwap_GetPixelMapfv", - "__glXDispSwap_GetPixelMapuiv", - "__glXDispSwap_GetPixelMapusv", - "__glXDispSwap_GetPolygonStipple", - "__glXDispSwap_GetSeparableFilter", - "__glXDispSwap_GetString", - "__glXDispSwap_GetTexEnvfv", - "__glXDispSwap_GetTexEnviv", - "__glXDispSwap_GetTexGendv", - "__glXDispSwap_GetTexGenfv", - "__glXDispSwap_GetTexGeniv", - "__glXDispSwap_GetTexImage", - "__glXDispSwap_GetTexLevelParameterfv", - "__glXDispSwap_GetTexLevelParameteriv", - "__glXDispSwap_GetTexParameterfv", - "__glXDispSwap_GetTexParameteriv", - "__glXDispSwap_Hint", - "__glXDispSwap_Histogram", - "__glXDispSwap_IndexMask", - "__glXDispSwap_Indexdv", - "__glXDispSwap_Indexfv", - "__glXDispSwap_Indexiv", - "__glXDispSwap_Indexsv", - "__glXDispSwap_Indexubv", - "__glXDispSwap_InitNames", - "__glXDispSwap_IsEnabled", - "__glXDispSwap_IsList", - "__glXDispSwap_IsTexture", - "__glXDispSwap_IsTextureEXT", - "__glXDispSwap_LightModelf", - "__glXDispSwap_LightModelfv", - "__glXDispSwap_LightModeli", - "__glXDispSwap_LightModeliv", - "__glXDispSwap_Lightf", - "__glXDispSwap_Lightfv", - "__glXDispSwap_Lighti", - "__glXDispSwap_Lightiv", - "__glXDispSwap_LineStipple", - "__glXDispSwap_LineWidth", - "__glXDispSwap_ListBase", - "__glXDispSwap_LoadIdentity", - "__glXDispSwap_LoadMatrixd", - "__glXDispSwap_LoadMatrixf", - "__glXDispSwap_LoadName", - "__glXDispSwap_LogicOp", - "__glXDispSwap_Map1d", - "__glXDispSwap_Map1f", - "__glXDispSwap_Map2d", - "__glXDispSwap_Map2f", - "__glXDispSwap_MapGrid1d", - "__glXDispSwap_MapGrid1f", - "__glXDispSwap_MapGrid2d", - "__glXDispSwap_MapGrid2f", - "__glXDispSwap_Materialf", - "__glXDispSwap_Materialfv", - "__glXDispSwap_Materiali", - "__glXDispSwap_Materialiv", - "__glXDispSwap_MatrixMode", - "__glXDispSwap_Minmax", - "__glXDispSwap_MultMatrixd", - "__glXDispSwap_MultMatrixf", - "__glXDispSwap_MultiTexCoord1dvARB", - "__glXDispSwap_MultiTexCoord1fvARB", - "__glXDispSwap_MultiTexCoord1ivARB", - "__glXDispSwap_MultiTexCoord1svARB", - "__glXDispSwap_MultiTexCoord2dvARB", - "__glXDispSwap_MultiTexCoord2fvARB", - "__glXDispSwap_MultiTexCoord2ivARB", - "__glXDispSwap_MultiTexCoord2svARB", - "__glXDispSwap_MultiTexCoord3dvARB", - "__glXDispSwap_MultiTexCoord3fvARB", - "__glXDispSwap_MultiTexCoord3ivARB", - "__glXDispSwap_MultiTexCoord3svARB", - "__glXDispSwap_MultiTexCoord4dvARB", - "__glXDispSwap_MultiTexCoord4fvARB", - "__glXDispSwap_MultiTexCoord4ivARB", - "__glXDispSwap_MultiTexCoord4svARB", - "__glXDispSwap_NewList", - "__glXDispSwap_Normal3bv", - "__glXDispSwap_Normal3dv", - "__glXDispSwap_Normal3fv", - "__glXDispSwap_Normal3iv", - "__glXDispSwap_Normal3sv", - "__glXDispSwap_Ortho", - "__glXDispSwap_PassThrough", - "__glXDispSwap_PixelMapfv", - "__glXDispSwap_PixelMapuiv", - "__glXDispSwap_PixelMapusv", - "__glXDispSwap_PixelStoref", - "__glXDispSwap_PixelStorei", - "__glXDispSwap_PixelTransferf", - "__glXDispSwap_PixelTransferi", - "__glXDispSwap_PixelZoom", - "__glXDispSwap_PointParameterfARB", - "__glXDispSwap_PointParameterfvARB", - "__glXDispSwap_PointSize", - "__glXDispSwap_PolygonMode", - "__glXDispSwap_PolygonOffset", - "__glXDispSwap_PolygonStipple", - "__glXDispSwap_PopAttrib", - "__glXDispSwap_PopMatrix", - "__glXDispSwap_PopName", - "__glXDispSwap_PrioritizeTextures", - "__glXDispSwap_PushAttrib", - "__glXDispSwap_PushMatrix", - "__glXDispSwap_PushName", - "__glXDispSwap_RasterPos2dv", - "__glXDispSwap_RasterPos2fv", - "__glXDispSwap_RasterPos2iv", - "__glXDispSwap_RasterPos2sv", - "__glXDispSwap_RasterPos3dv", - "__glXDispSwap_RasterPos3fv", - "__glXDispSwap_RasterPos3iv", - "__glXDispSwap_RasterPos3sv", - "__glXDispSwap_RasterPos4dv", - "__glXDispSwap_RasterPos4fv", - "__glXDispSwap_RasterPos4iv", - "__glXDispSwap_RasterPos4sv", - "__glXDispSwap_ReadBuffer", - "__glXDispSwap_ReadPixels", - "__glXDispSwap_Rectdv", - "__glXDispSwap_Rectfv", - "__glXDispSwap_Rectiv", - "__glXDispSwap_Rectsv", - "__glXDispSwap_RenderMode", - "__glXDispSwap_ResetHistogram", - "__glXDispSwap_ResetMinmax", - "__glXDispSwap_Rotated", - "__glXDispSwap_Rotatef", - "__glXDispSwap_Scaled", - "__glXDispSwap_Scalef", - "__glXDispSwap_Scissor", - "__glXDispSwap_SelectBuffer", - "__glXDispSwap_SeparableFilter2D", - "__glXDispSwap_ShadeModel", - "__glXDispSwap_StencilFunc", - "__glXDispSwap_StencilMask", - "__glXDispSwap_StencilOp", - "__glXDispSwap_TexCoord1dv", - "__glXDispSwap_TexCoord1fv", - "__glXDispSwap_TexCoord1iv", - "__glXDispSwap_TexCoord1sv", - "__glXDispSwap_TexCoord2dv", - "__glXDispSwap_TexCoord2fv", - "__glXDispSwap_TexCoord2iv", - "__glXDispSwap_TexCoord2sv", - "__glXDispSwap_TexCoord3dv", - "__glXDispSwap_TexCoord3fv", - "__glXDispSwap_TexCoord3iv", - "__glXDispSwap_TexCoord3sv", - "__glXDispSwap_TexCoord4dv", - "__glXDispSwap_TexCoord4fv", - "__glXDispSwap_TexCoord4iv", - "__glXDispSwap_TexCoord4sv", - "__glXDispSwap_TexEnvf", - "__glXDispSwap_TexEnvfv", - "__glXDispSwap_TexEnvi", - "__glXDispSwap_TexEnviv", - "__glXDispSwap_TexGend", - "__glXDispSwap_TexGendv", - "__glXDispSwap_TexGenf", - "__glXDispSwap_TexGenfv", - "__glXDispSwap_TexGeni", - "__glXDispSwap_TexGeniv", - "__glXDispSwap_TexImage1D", - "__glXDispSwap_TexImage2D", - "__glXDispSwap_TexImage3D", - "__glXDispSwap_TexParameterf", - "__glXDispSwap_TexParameterfv", - "__glXDispSwap_TexParameteri", - "__glXDispSwap_TexParameteriv", - "__glXDispSwap_TexSubImage1D", - "__glXDispSwap_TexSubImage2D", - "__glXDispSwap_TexSubImage3D", - "__glXDispSwap_Translated", - "__glXDispSwap_Translatef", - "__glXDispSwap_Vertex2dv", - "__glXDispSwap_Vertex2fv", - "__glXDispSwap_Vertex2iv", - "__glXDispSwap_Vertex2sv", - "__glXDispSwap_Vertex3dv", - "__glXDispSwap_Vertex3fv", - "__glXDispSwap_Vertex3iv", - "__glXDispSwap_Vertex3sv", - "__glXDispSwap_Vertex4dv", - "__glXDispSwap_Vertex4fv", - "__glXDispSwap_Vertex4iv", - "__glXDispSwap_Vertex4sv", - "__glXDispSwap_Viewport", - "__glXDispSwap_WindowPos3fARB", - "__glXDisp_Accum", - "__glXDisp_ActiveStencilFaceEXT", - "__glXDisp_ActiveTextureARB", - "__glXDisp_AlphaFunc", - "__glXDisp_AreTexturesResident", - "__glXDisp_AreTexturesResidentEXT", - "__glXDisp_Begin", - "__glXDisp_BindTexture", - "__glXDisp_Bitmap", - "__glXDisp_BlendColor", - "__glXDisp_BlendEquation", - "__glXDisp_BlendFunc", - "__glXDisp_CallList", - "__glXDisp_CallLists", - "__glXDisp_Clear", - "__glXDisp_ClearAccum", - "__glXDisp_ClearColor", - "__glXDisp_ClearDepth", - "__glXDisp_ClearIndex", - "__glXDisp_ClearStencil", - "__glXDisp_ClipPlane", - "__glXDisp_Color3bv", - "__glXDisp_Color3dv", - "__glXDisp_Color3fv", - "__glXDisp_Color3iv", - "__glXDisp_Color3sv", - "__glXDisp_Color3ubv", - "__glXDisp_Color3uiv", - "__glXDisp_Color3usv", - "__glXDisp_Color4bv", - "__glXDisp_Color4dv", - "__glXDisp_Color4fv", - "__glXDisp_Color4iv", - "__glXDisp_Color4sv", - "__glXDisp_Color4ubv", - "__glXDisp_Color4uiv", - "__glXDisp_Color4usv", - "__glXDisp_ColorMask", - "__glXDisp_ColorMaterial", - "__glXDisp_ColorSubTable", - "__glXDisp_ColorTable", - "__glXDisp_ColorTableParameterfv", - "__glXDisp_ColorTableParameteriv", - "__glXDisp_ConvolutionFilter1D", - "__glXDisp_ConvolutionFilter2D", - "__glXDisp_ConvolutionParameterf", - "__glXDisp_ConvolutionParameterfv", - "__glXDisp_ConvolutionParameteri", - "__glXDisp_ConvolutionParameteriv", - "__glXDisp_CopyColorSubTable", - "__glXDisp_CopyColorTable", - "__glXDisp_CopyConvolutionFilter1D", - "__glXDisp_CopyConvolutionFilter2D", - "__glXDisp_CopyPixels", - "__glXDisp_CopyTexImage1D", - "__glXDisp_CopyTexImage2D", - "__glXDisp_CopyTexSubImage1D", - "__glXDisp_CopyTexSubImage2D", - "__glXDisp_CopyTexSubImage3D", - "__glXDisp_CullFace", - "__glXDisp_DeleteLists", - "__glXDisp_DeleteTextures", - "__glXDisp_DeleteTexturesEXT", - "__glXDisp_DepthFunc", - "__glXDisp_DepthMask", - "__glXDisp_DepthRange", - "__glXDisp_Disable", - "__glXDisp_DrawArrays", - "__glXDisp_DrawArraysEXT", - "__glXDisp_DrawBuffer", - "__glXDisp_DrawPixels", - "__glXDisp_EdgeFlagv", - "__glXDisp_Enable", - "__glXDisp_End", - "__glXDisp_EndList", - "__glXDisp_EvalCoord1dv", - "__glXDisp_EvalCoord1fv", - "__glXDisp_EvalCoord2dv", - "__glXDisp_EvalCoord2fv", - "__glXDisp_EvalMesh1", - "__glXDisp_EvalMesh2", - "__glXDisp_EvalPoint1", - "__glXDisp_EvalPoint2", - "__glXDisp_FeedbackBuffer", - "__glXDisp_Finish", - "__glXDisp_Flush", - "__glXDisp_Fogf", - "__glXDisp_Fogfv", - "__glXDisp_Fogi", - "__glXDisp_Fogiv", - "__glXDisp_FrontFace", - "__glXDisp_Frustum", - "__glXDisp_GenLists", - "__glXDisp_GenTextures", - "__glXDisp_GenTexturesEXT", - "__glXDisp_GetBooleanv", - "__glXDisp_GetClipPlane", - "__glXDisp_GetColorTable", - "__glXDisp_GetColorTableParameterfv", - "__glXDisp_GetColorTableParameteriv", - "__glXDisp_GetConvolutionFilter", - "__glXDisp_GetConvolutionParameterfv", - "__glXDisp_GetConvolutionParameteriv", - "__glXDisp_GetDoublev", - "__glXDisp_GetError", - "__glXDisp_GetFloatv", - "__glXDisp_GetHistogram", - "__glXDisp_GetHistogramParameterfv", - "__glXDisp_GetHistogramParameteriv", - "__glXDisp_GetIntegerv", - "__glXDisp_GetLightfv", - "__glXDisp_GetLightiv", - "__glXDisp_GetMapdv", - "__glXDisp_GetMapfv", - "__glXDisp_GetMapiv", - "__glXDisp_GetMaterialfv", - "__glXDisp_GetMaterialiv", - "__glXDisp_GetMinmax", - "__glXDisp_GetMinmaxParameterfv", - "__glXDisp_GetMinmaxParameteriv", - "__glXDisp_GetPixelMapfv", - "__glXDisp_GetPixelMapuiv", - "__glXDisp_GetPixelMapusv", - "__glXDisp_GetPolygonStipple", - "__glXDisp_GetSeparableFilter", - "__glXDisp_GetString", - "__glXDisp_GetTexEnvfv", - "__glXDisp_GetTexEnviv", - "__glXDisp_GetTexGendv", - "__glXDisp_GetTexGenfv", - "__glXDisp_GetTexGeniv", - "__glXDisp_GetTexImage", - "__glXDisp_GetTexLevelParameterfv", - "__glXDisp_GetTexLevelParameteriv", - "__glXDisp_GetTexParameterfv", - "__glXDisp_GetTexParameteriv", - "__glXDisp_Hint", - "__glXDisp_Histogram", - "__glXDisp_IndexMask", - "__glXDisp_Indexdv", - "__glXDisp_Indexfv", - "__glXDisp_Indexiv", - "__glXDisp_Indexsv", - "__glXDisp_Indexubv", - "__glXDisp_InitNames", - "__glXDisp_IsEnabled", - "__glXDisp_IsList", - "__glXDisp_IsTexture", - "__glXDisp_IsTextureEXT", - "__glXDisp_LightModelf", - "__glXDisp_LightModelfv", - "__glXDisp_LightModeli", - "__glXDisp_LightModeliv", - "__glXDisp_Lightf", - "__glXDisp_Lightfv", - "__glXDisp_Lighti", - "__glXDisp_Lightiv", - "__glXDisp_LineStipple", - "__glXDisp_LineWidth", - "__glXDisp_ListBase", - "__glXDisp_LoadIdentity", - "__glXDisp_LoadMatrixd", - "__glXDisp_LoadMatrixf", - "__glXDisp_LoadName", - "__glXDisp_LogicOp", - "__glXDisp_Map1d", - "__glXDisp_Map1f", - "__glXDisp_Map2d", - "__glXDisp_Map2f", - "__glXDisp_MapGrid1d", - "__glXDisp_MapGrid1f", - "__glXDisp_MapGrid2d", - "__glXDisp_MapGrid2f", - "__glXDisp_Materialf", - "__glXDisp_Materialfv", - "__glXDisp_Materiali", - "__glXDisp_Materialiv", - "__glXDisp_MatrixMode", - "__glXDisp_Minmax", - "__glXDisp_MultMatrixd", - "__glXDisp_MultMatrixf", - "__glXDisp_MultiTexCoord1dvARB", - "__glXDisp_MultiTexCoord1fvARB", - "__glXDisp_MultiTexCoord1ivARB", - "__glXDisp_MultiTexCoord1svARB", - "__glXDisp_MultiTexCoord2dvARB", - "__glXDisp_MultiTexCoord2fvARB", - "__glXDisp_MultiTexCoord2ivARB", - "__glXDisp_MultiTexCoord2svARB", - "__glXDisp_MultiTexCoord3dvARB", - "__glXDisp_MultiTexCoord3fvARB", - "__glXDisp_MultiTexCoord3ivARB", - "__glXDisp_MultiTexCoord3svARB", - "__glXDisp_MultiTexCoord4dvARB", - "__glXDisp_MultiTexCoord4fvARB", - "__glXDisp_MultiTexCoord4ivARB", - "__glXDisp_MultiTexCoord4svARB", - "__glXDisp_NewList", - "__glXDisp_Normal3bv", - "__glXDisp_Normal3dv", - "__glXDisp_Normal3fv", - "__glXDisp_Normal3iv", - "__glXDisp_Normal3sv", - "__glXDisp_Ortho", - "__glXDisp_PassThrough", - "__glXDisp_PixelMapfv", - "__glXDisp_PixelMapuiv", - "__glXDisp_PixelMapusv", - "__glXDisp_PixelStoref", - "__glXDisp_PixelStorei", - "__glXDisp_PixelTransferf", - "__glXDisp_PixelTransferi", - "__glXDisp_PixelZoom", - "__glXDisp_PointParameterfARB", - "__glXDisp_PointParameterfvARB", - "__glXDisp_PointSize", - "__glXDisp_PolygonMode", - "__glXDisp_PolygonOffset", - "__glXDisp_PolygonStipple", - "__glXDisp_PopAttrib", - "__glXDisp_PopMatrix", - "__glXDisp_PopName", - "__glXDisp_PrioritizeTextures", - "__glXDisp_PushAttrib", - "__glXDisp_PushMatrix", - "__glXDisp_PushName", - "__glXDisp_RasterPos2dv", - "__glXDisp_RasterPos2fv", - "__glXDisp_RasterPos2iv", - "__glXDisp_RasterPos2sv", - "__glXDisp_RasterPos3dv", - "__glXDisp_RasterPos3fv", - "__glXDisp_RasterPos3iv", - "__glXDisp_RasterPos3sv", - "__glXDisp_RasterPos4dv", - "__glXDisp_RasterPos4fv", - "__glXDisp_RasterPos4iv", - "__glXDisp_RasterPos4sv", - "__glXDisp_ReadBuffer", - "__glXDisp_ReadPixels", - "__glXDisp_Rectdv", - "__glXDisp_Rectfv", - "__glXDisp_Rectiv", - "__glXDisp_Rectsv", - "__glXDisp_RenderMode", - "__glXDisp_ResetHistogram", - "__glXDisp_ResetMinmax", - "__glXDisp_Rotated", - "__glXDisp_Rotatef", - "__glXDisp_Scaled", - "__glXDisp_Scalef", - "__glXDisp_Scissor", - "__glXDisp_SelectBuffer", - "__glXDisp_SeparableFilter2D", - "__glXDisp_ShadeModel", - "__glXDisp_StencilFunc", - "__glXDisp_StencilMask", - "__glXDisp_StencilOp", - "__glXDisp_TexCoord1dv", - "__glXDisp_TexCoord1fv", - "__glXDisp_TexCoord1iv", - "__glXDisp_TexCoord1sv", - "__glXDisp_TexCoord2dv", - "__glXDisp_TexCoord2fv", - "__glXDisp_TexCoord2iv", - "__glXDisp_TexCoord2sv", - "__glXDisp_TexCoord3dv", - "__glXDisp_TexCoord3fv", - "__glXDisp_TexCoord3iv", - "__glXDisp_TexCoord3sv", - "__glXDisp_TexCoord4dv", - "__glXDisp_TexCoord4fv", - "__glXDisp_TexCoord4iv", - "__glXDisp_TexCoord4sv", - "__glXDisp_TexEnvf", - "__glXDisp_TexEnvfv", - "__glXDisp_TexEnvi", - "__glXDisp_TexEnviv", - "__glXDisp_TexGend", - "__glXDisp_TexGendv", - "__glXDisp_TexGenf", - "__glXDisp_TexGenfv", - "__glXDisp_TexGeni", - "__glXDisp_TexGeniv", - "__glXDisp_TexImage1D", - "__glXDisp_TexImage2D", - "__glXDisp_TexImage3D", - "__glXDisp_TexParameterf", - "__glXDisp_TexParameterfv", - "__glXDisp_TexParameteri", - "__glXDisp_TexParameteriv", - "__glXDisp_TexSubImage1D", - "__glXDisp_TexSubImage2D", - "__glXDisp_TexSubImage3D", - "__glXDisp_Translated", - "__glXDisp_Translatef", - "__glXDisp_Vertex2dv", - "__glXDisp_Vertex2fv", - "__glXDisp_Vertex2iv", - "__glXDisp_Vertex2sv", - "__glXDisp_Vertex3dv", - "__glXDisp_Vertex3fv", - "__glXDisp_Vertex3iv", - "__glXDisp_Vertex3sv", - "__glXDisp_Vertex4dv", - "__glXDisp_Vertex4fv", - "__glXDisp_Vertex4iv", - "__glXDisp_Vertex4sv", - "__glXDisp_Viewport", - "__glXDisp_WindowPos3fARB", - "__glXDrawArraysSize", - "__glXDrawPixelsReqSize", - "__glXDrawableRes", - "__glXErrorOccured", - "__glXFBInitDrawable", - "__glXFBMemSwapBuffers", - "__glXFindDrawablePrivate", - "__glXFogfvReqSize", - "__glXFogivReqSize", - "__glXForceCurrent", - "__glXFree", - "__glXFreeBuffers", - "__glXFreeContext", - "__glXGetDrawablePrivate", - "__glXGetVisualConfigs", - "__glXImageSize", - "__glXImpAtoi", - "__glXImpCalloc", - "__glXImpFatal", - "__glXImpFclose", - "__glXImpFopen", - "__glXImpFprintf", - "__glXImpFree", - "__glXImpGetDrawablePrivate", - "__glXImpGetenv", - "__glXImpMalloc", - "__glXImpRealloc", - "__glXImpSprintf", - "__glXImpWarning", - "__glXInitFB", - "__glXInitMem", - "__glXInitPix", - "__glXIsDirect", - "__glXLastContext", - "__glXLightModelfvReqSize", - "__glXLightModelivReqSize", - "__glXLightfvReqSize", - "__glXLightivReqSize", - "__glXLookupContextByTag", - "__glXMakeCurrent", - "__glXMalloc", - "__glXMap1dReqSize", - "__glXMap1fReqSize", - "__glXMap2dReqSize", - "__glXMap2fReqSize", - "__glXMaterialfvReqSize", - "__glXMaterialivReqSize", - "__glXNoSuchRenderOpcode", - "__glXNoSuchSingleOpcode", - "__glXNop", - "__glXPixInitDrawable", - "__glXPixelMapfvReqSize", - "__glXPixelMapuivReqSize", - "__glXPixelMapusvReqSize", - "__glXPixmapRes", - "__glXPrioritizeTexturesReqSize", - "__glXQueryContextInfoEXT", - "__glXQueryExtensionsString", - "__glXQueryServerString", - "__glXQueryVersion", - "__glXRealloc", - "__glXRender", - "__glXRenderLarge", - "__glXRenderSizeTable", - "__glXRenderSizeTable_EXT", - "__glXRenderTable", - "__glXRenderTable_EXT", - "__glXReply", - "__glXResetLargeCommandStatus", - "__glXResizeBuffers", - "__glXResizeDrawableBuffers", - "__glXScreenInit", - "__glXScreenReset", - "__glXSeparableFilter2DReqSize", - "__glXSingleTable", - "__glXSwapBuffers", - "__glXSwapClientInfo", - "__glXSwapCopyContext", - "__glXSwapCreateContext", - "__glXSwapCreateGLXPixmap", - "__glXSwapDestroyContext", - "__glXSwapDestroyGLXPixmap", - "__glXSwapGetVisualConfigs", - "__glXSwapIsDirect", - "__glXSwapIsDirectReply", - "__glXSwapMakeCurrent", - "__glXSwapMakeCurrentReply", - "__glXSwapQueryContextInfoEXTReply", - "__glXSwapQueryExtensionsString", - "__glXSwapQueryServerString", - "__glXSwapQueryVersion", - "__glXSwapQueryVersionReply", - "__glXSwapRender", - "__glXSwapRenderLarge", - "__glXSwapRenderTable", - "__glXSwapRenderTable_EXT", - "__glXSwapSingleTable", - "__glXSwapSwapBuffers", - "__glXSwapUseXFont", - "__glXSwapVendorPrivTable_EXT", - "__glXSwapVendorPrivate", - "__glXSwapVendorPrivateWithReply", - "__glXSwapWaitGL", - "__glXSwapWaitX", - "__glXTexEnvfvReqSize", - "__glXTexEnvivReqSize", - "__glXTexGendvReqSize", - "__glXTexGenfvReqSize", - "__glXTexGenivReqSize", - "__glXTexImage1DReqSize", - "__glXTexImage2DReqSize", - "__glXTexImage3DReqSize", - "__glXTexParameterfvReqSize", - "__glXTexParameterivReqSize", - "__glXTexSubImage1DReqSize", - "__glXTexSubImage2DReqSize", - "__glXTexSubImage3DReqSize", - "__glXTypeSize", - "__glXUnrefDrawablePrivate", - "__glXUnsupportedPrivateRequest", - "__glXUseXFont", - "__glXVendorPrivTable_EXT", - "__glXVendorPrivate", - "__glXVendorPrivateWithReply", - "__glXWaitGL", - "__glXWaitX", - "__glXcombine_strings", - "glAccum", - "glActiveStencilFaceEXT", - "glActiveTextureARB", - "glAlphaFunc", - "glAreTexturesResident", - "glAreTexturesResidentEXT", - "glBegin", - "glBindTexture", - "glBitmap", - "glBlendColor", - "glBlendEquation", - "glBlendFunc", - "glCallList", - "glCallLists", - "glClear", - "glClearAccum", - "glClearColor", - "glClearDepth", - "glClearIndex", - "glClearStencil", - "glClipPlane", - "glColor3bv", - "glColor3dv", - "glColor3fv", - "glColor3iv", - "glColor3sv", - "glColor3ubv", - "glColor3uiv", - "glColor3usv", - "glColor4bv", - "glColor4dv", - "glColor4fv", - "glColor4iv", - "glColor4sv", - "glColor4ubv", - "glColor4uiv", - "glColor4usv", - "glColorMask", - "glColorMaterial", - "glColorPointer", - "glColorSubTable", - "glColorTable", - "glColorTableParameterfv", - "glColorTableParameteriv", - "glConvolutionFilter1D", - "glConvolutionFilter2D", - "glConvolutionParameterf", - "glConvolutionParameterfv", - "glConvolutionParameteri", - "glConvolutionParameteriv", - "glCopyColorSubTable", - "glCopyColorTable", - "glCopyConvolutionFilter1D", - "glCopyConvolutionFilter2D", - "glCopyPixels", - "glCopyTexImage1D", - "glCopyTexImage2D", - "glCopyTexSubImage1D", - "glCopyTexSubImage2D", - "glCopyTexSubImage3D", - "glCullFace", - "glDeleteLists", - "glDeleteTextures", - "glDeleteTexturesEXT", - "glDepthFunc", - "glDepthMask", - "glDepthRange", - "glDisable", - "glDisableClientState", - "glDrawArrays", - "glDrawBuffer", - "glDrawPixels", - "glEdgeFlagPointer", - "glEdgeFlagv", - "glEnable", - "glEnableClientState", - "glEnd", - "glEndList", - "glEvalCoord1dv", - "glEvalCoord1fv", - "glEvalCoord2dv", - "glEvalCoord2fv", - "glEvalMesh1", - "glEvalMesh2", - "glEvalPoint1", - "glEvalPoint2", - "glFeedbackBuffer", - "glFinish", - "glFlush", - "glFogf", - "glFogfv", - "glFogi", - "glFogiv", - "glFrontFace", - "glFrustum", - "glGenLists", - "glGenTextures", - "glGenTexturesEXT", - "glGetBooleanv", - "glGetClipPlane", - "glGetColorTable", - "glGetColorTableParameterfv", - "glGetColorTableParameteriv", - "glGetConvolutionFilter", - "glGetConvolutionParameterfv", - "glGetConvolutionParameteriv", - "glGetDoublev", - "glGetError", - "glGetFloatv", - "glGetHistogram", - "glGetHistogramParameterfv", - "glGetHistogramParameteriv", - "glGetIntegerv", - "glGetLightfv", - "glGetLightiv", - "glGetMapdv", - "glGetMapfv", - "glGetMapiv", - "glGetMaterialfv", - "glGetMaterialiv", - "glGetMinmax", - "glGetMinmaxParameterfv", - "glGetMinmaxParameteriv", - "glGetPixelMapfv", - "glGetPixelMapuiv", - "glGetPixelMapusv", - "glGetPolygonStipple", - "glGetSeparableFilter", - "glGetString", - "glGetTexEnvfv", - "glGetTexEnviv", - "glGetTexGendv", - "glGetTexGenfv", - "glGetTexGeniv", - "glGetTexImage", - "glGetTexLevelParameterfv", - "glGetTexLevelParameteriv", - "glGetTexParameterfv", - "glGetTexParameteriv", - "glHint", - "glHistogram", - "glIndexMask", - "glIndexPointer", - "glIndexdv", - "glIndexfv", - "glIndexiv", - "glIndexsv", - "glIndexubv", - "glInitNames", - "glIsEnabled", - "glIsList", - "glIsTexture", - "glIsTextureEXT", - "glLightModelf", - "glLightModelfv", - "glLightModeli", - "glLightModeliv", - "glLightf", - "glLightfv", - "glLighti", - "glLightiv", - "glLineStipple", - "glLineWidth", - "glListBase", - "glLoadIdentity", - "glLoadMatrixd", - "glLoadMatrixf", - "glLoadName", - "glLogicOp", - "glMap1d", - "glMap1f", - "glMap2d", - "glMap2f", - "glMapGrid1d", - "glMapGrid1f", - "glMapGrid2d", - "glMapGrid2f", - "glMaterialf", - "glMaterialfv", - "glMateriali", - "glMaterialiv", - "glMatrixMode", - "glMinmax", - "glMultMatrixd", - "glMultMatrixf", - "glMultiTexCoord1dvARB", - "glMultiTexCoord1fvARB", - "glMultiTexCoord1ivARB", - "glMultiTexCoord1svARB", - "glMultiTexCoord2dvARB", - "glMultiTexCoord2fvARB", - "glMultiTexCoord2ivARB", - "glMultiTexCoord2svARB", - "glMultiTexCoord3dvARB", - "glMultiTexCoord3fvARB", - "glMultiTexCoord3ivARB", - "glMultiTexCoord3svARB", - "glMultiTexCoord4dvARB", - "glMultiTexCoord4fvARB", - "glMultiTexCoord4ivARB", - "glMultiTexCoord4svARB", - "glNewList", - "glNormal3bv", - "glNormal3dv", - "glNormal3fv", - "glNormal3iv", - "glNormal3sv", - "glNormalPointer", - "glOrtho", - "glPassThrough", - "glPixelMapfv", - "glPixelMapuiv", - "glPixelMapusv", - "glPixelStoref", - "glPixelStorei", - "glPixelTransferf", - "glPixelTransferi", - "glPixelZoom", - "glPointParameterfARB", - "glPointParameterfvARB", - "glPointSize", - "glPolygonMode", - "glPolygonOffset", - "glPolygonStipple", - "glPopAttrib", - "glPopMatrix", - "glPopName", - "glPrioritizeTextures", - "glPushAttrib", - "glPushMatrix", - "glPushName", - "glRasterPos2dv", - "glRasterPos2fv", - "glRasterPos2iv", - "glRasterPos2sv", - "glRasterPos3dv", - "glRasterPos3fv", - "glRasterPos3iv", - "glRasterPos3sv", - "glRasterPos4dv", - "glRasterPos4fv", - "glRasterPos4iv", - "glRasterPos4sv", - "glReadBuffer", - "glReadPixels", - "glRectdv", - "glRectfv", - "glRectiv", - "glRectsv", - "glRenderMode", - "glResetHistogram", - "glResetMinmax", - "glRotated", - "glRotatef", - "glScaled", - "glScalef", - "glScissor", - "glSelectBuffer", - "glSeparableFilter2D", - "glShadeModel", - "glStencilFunc", - "glStencilMask", - "glStencilOp", - "glTexCoord1dv", - "glTexCoord1fv", - "glTexCoord1iv", - "glTexCoord1sv", - "glTexCoord2dv", - "glTexCoord2fv", - "glTexCoord2iv", - "glTexCoord2sv", - "glTexCoord3dv", - "glTexCoord3fv", - "glTexCoord3iv", - "glTexCoord3sv", - "glTexCoord4dv", - "glTexCoord4fv", - "glTexCoord4iv", - "glTexCoord4sv", - "glTexCoordPointer", - "glTexEnvf", - "glTexEnvfv", - "glTexEnvi", - "glTexEnviv", - "glTexGend", - "glTexGendv", - "glTexGenf", - "glTexGenfv", - "glTexGeni", - "glTexGeniv", - "glTexImage1D", - "glTexImage2D", - "glTexImage3D", - "glTexParameterf", - "glTexParameterfv", - "glTexParameteri", - "glTexParameteriv", - "glTexSubImage1D", - "glTexSubImage2D", - "glTexSubImage3D", - "glTranslated", - "glTranslatef", - "glVertex2dv", - "glVertex2fv", - "glVertex2iv", - "glVertex2sv", - "glVertex3dv", - "glVertex3fv", - "glVertex3iv", - "glVertex3sv", - "glVertex4dv", - "glVertex4fv", - "glVertex4iv", - "glVertex4sv", - "glVertexPointer", - "glViewport", - "glWindowPos3fARB", - "glxSwapQueryExtensionsStringReply", - "glxSwapQueryServerStringReply", - NULL -}; - static XF86ModuleVersionInfo VersRec = { "glx", @@ -1236,35 +84,68 @@ static XF86ModuleVersionInfo VersRec = XF86ModuleData glxModuleData = { &VersRec, glxSetup, NULL }; +/* We do a little proxy dance here, so we can avoid loading GLcore + * unless we really need to.*/ + +static pointer glxModule; + +static __GLXscreen * +__glXMesaProxyScreenProbe(ScreenPtr pScreen) +{ + pointer GLcore; + static __GLXprovider *provider; + + if (provider == NULL) { + GLcore = LoadSubModuleLocal(glxModule, "GLcore", NULL, NULL, NULL, NULL, + NULL, NULL); + if (GLcore == NULL) + return NULL; + + provider = LoaderSymbol("__glXMesaProvider"); + if (provider == NULL) + return NULL; + } + + return provider->screenProbe(pScreen); +} + +static __GLXprovider __glXMesaProxyProvider = { + __glXMesaProxyScreenProbe, + "MESA-PROXY", + NULL +}; + + static pointer glxSetup(pointer module, pointer opts, int *errmaj, int *errmin) { static Bool setupDone = FALSE; - pointer GLcore = NULL; -#ifdef GLX_USE_SGI_SI - char GLcoreName[] = "GL"; -#else - char GLcoreName[] = "GLcore"; -#endif + __GLXprovider *provider; - if (!setupDone) { - setupDone = TRUE; - - GLcore = LoadSubModule(module, GLcoreName, NULL, NULL, NULL, NULL, - errmaj, errmin); - if (!GLcore) { - if (errmaj) *errmaj = LDR_NOSUBENT; - } else { - LoaderReqSymLists(glcoreSymbols, NULL); - LoadExtension(&GLXExt, FALSE); - /* Wrap the init visuals routine in micmap.c */ - GlxWrapInitVisuals(&miInitVisualsProc); - /* Make sure this gets wrapped each time InitVisualWrap is called */ - miHookInitVisuals(NULL, GlxWrapInitVisuals); - } - } else { + if (setupDone) { if (errmaj) *errmaj = LDR_ONCEONLY; + return NULL; + } + + setupDone = TRUE; + + glxModule = module; + GlxPushProvider(&__glXMesaProxyProvider); + + xf86Msg(xf86Info.aiglxFrom, "AIGLX %s\n", + xf86Info.aiglx ? "enabled" : "disabled"); + if (xf86Info.aiglx) { + provider = LoaderSymbol("__glXDRIProvider"); + if (provider) + GlxPushProvider(provider); } - /* Need a non-NULL return value to indicate success */ - return GLcore; + + LoadExtension(&GLXExt, FALSE); + /* Wrap the init visuals routine in micmap.c */ + GlxWrapInitVisuals(&miInitVisualsProc); + /* Make sure this gets wrapped each time InitVisualWrap is called */ + miHookInitVisuals(NULL, GlxWrapInitVisuals); + + bail: + return module; } diff --git a/hw/xfree86/dri/dri.c b/hw/xfree86/dri/dri.c index dcd455ce0..8003f0df5 100644 --- a/hw/xfree86/dri/dri.c +++ b/hw/xfree86/dri/dri.c @@ -779,7 +779,7 @@ static Bool DRICreateDummyContext(ScreenPtr pScreen, Bool needCtxPriv) { DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen); - __GLXscreenInfo *pGLXScreen = __glXgetActiveScreen(pScreen->myNum); + __GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum); __GLcontextModes *modes = pGLXScreen->modes; void **pVisualConfigPriv = pGLXScreen->pVisualPriv; DRIContextPrivPtr pDRIContextPriv; @@ -843,7 +843,7 @@ DRICreateContext(ScreenPtr pScreen, VisualPtr visual, XID context, drm_context_t * pHWContext) { DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen); - __GLXscreenInfo *pGLXScreen = __glXgetActiveScreen(pScreen->myNum); + __GLXscreen *pGLXScreen = __glXgetActiveScreen(pScreen->myNum); __GLcontextModes *modes = pGLXScreen->modes; void **pVisualConfigPriv = pGLXScreen->pVisualPriv; DRIContextPrivPtr pDRIContextPriv; diff --git a/hw/xfree86/loader/aoutloader.c b/hw/xfree86/loader/aoutloader.c index e03e80ef2..13500b93b 100644 --- a/hw/xfree86/loader/aoutloader.c +++ b/hw/xfree86/loader/aoutloader.c @@ -630,7 +630,7 @@ AOUT_GetSymbols(AOUTModulePtr aoutfile) * Public API for the a.out implementation of the loader */ void * -AOUTLoadModule(loaderPtr modrec, int aoutfd, LOOKUP ** ppLookup) +AOUTLoadModule(loaderPtr modrec, int aoutfd, LOOKUP ** ppLookup, int flags) { AOUTModulePtr aoutfile = NULL; AOUTHDR *header; diff --git a/hw/xfree86/loader/aoutloader.h b/hw/xfree86/loader/aoutloader.h index f906816f7..8c04a16eb 100644 --- a/hw/xfree86/loader/aoutloader.h +++ b/hw/xfree86/loader/aoutloader.h @@ -27,7 +27,7 @@ #ifndef _AOUTLOADER_H #define _AOUTLOADER_H -extern void *AOUTLoadModule(loaderPtr, int, LOOKUP **); +extern void *AOUTLoadModule(loaderPtr, int, LOOKUP **, int flags); extern void AOUTResolveSymbols(void *); extern int AOUTCheckForUnresolved(void *); extern char *AOUTAddressToSection(void *, unsigned long); diff --git a/hw/xfree86/loader/coffloader.c b/hw/xfree86/loader/coffloader.c index 298ca5d61..d29b39a72 100644 --- a/hw/xfree86/loader/coffloader.c +++ b/hw/xfree86/loader/coffloader.c @@ -1149,7 +1149,7 @@ COFFCollectSections(COFFModulePtr cofffile) * Public API for the COFF implementation of the loader. */ void * -COFFLoadModule(loaderPtr modrec, int cofffd, LOOKUP **ppLookup) +COFFLoadModule(loaderPtr modrec, int cofffd, LOOKUP **ppLookup, int flags) { COFFModulePtr cofffile; FILHDR *header; diff --git a/hw/xfree86/loader/coffloader.h b/hw/xfree86/loader/coffloader.h index 75cd542c8..0dc4720c3 100644 --- a/hw/xfree86/loader/coffloader.h +++ b/hw/xfree86/loader/coffloader.h @@ -30,7 +30,7 @@ #ifndef _COFFLOADER_H #define _COFFLOADER_H /* coffloader.c */ -extern void *COFFLoadModule(loaderPtr, int, LOOKUP **); +extern void *COFFLoadModule(loaderPtr, int, LOOKUP **, int flags); extern void COFFResolveSymbols(void *); extern int COFFCheckForUnresolved(void *); extern char *COFFAddressToSection(void *, unsigned long); diff --git a/hw/xfree86/loader/dlloader.c b/hw/xfree86/loader/dlloader.c index 224157d43..835deda49 100644 --- a/hw/xfree86/loader/dlloader.c +++ b/hw/xfree86/loader/dlloader.c @@ -63,8 +63,6 @@ #endif #endif -#define DLOPEN_FLAGS ( DLOPEN_LAZY | DLOPEN_GLOBAL ) - #if defined(CSRG_BASED) && !defined(__ELF__) #define NEED_UNDERSCORE_FOR_DLLSYM #endif @@ -76,6 +74,7 @@ typedef struct { int handle; void *dlhandle; + int flags; } DLModuleRec, *DLModulePtr; /* @@ -88,6 +87,28 @@ typedef struct DLModuleList { DLModuleList *dlModuleList = NULL; +void * +DLFindSymbolLocal(pointer module, const char *name) +{ + DLModulePtr dlfile = module; + void *p; + char *n; + +#ifdef NEED_UNDERSCORE_FOR_DLLSYM + static const char symPrefix[] = "_"; +#else + static const char symPrefix[] = ""; +#endif + + n = xf86loadermalloc(strlen(symPrefix) + strlen(name) + 1); + sprintf(n, "%s%s", symPrefix, name); + p = dlsym(dlfile->dlhandle, n); + xf86loaderfree(n); + + return p; +} + + /* * Search a symbol in the module list */ @@ -97,30 +118,11 @@ DLFindSymbol(const char *name) DLModuleList *l; void *p; -#ifdef NEED_UNDERSCORE_FOR_DLLSYM - char *n; - - n = xf86loadermalloc(strlen(name) + 2); - sprintf(n, "_%s", name); -#endif - - (void)dlerror(); /* Clear out any previous error */ for (l = dlModuleList; l != NULL; l = l->next) { -#ifdef NEED_UNDERSCORE_FOR_DLLSYM - p = dlsym(l->module->dlhandle, n); -#else - p = dlsym(l->module->dlhandle, name); -#endif - if (dlerror() == NULL) { -#ifdef NEED_UNDERSCORE_FOR_DLLSYM - xf86loaderfree(n); -#endif + p = DLFindSymbolLocal(l->module, name); + if (p) return p; - } } -#ifdef NEED_UNDERSCORE_FOR_DLLSYM - xf86loaderfree(n); -#endif return NULL; } @@ -129,23 +131,28 @@ DLFindSymbol(const char *name) * public interface */ void * -DLLoadModule(loaderPtr modrec, int fd, LOOKUP ** ppLookup) +DLLoadModule(loaderPtr modrec, int fd, LOOKUP ** ppLookup, int flags) { DLModulePtr dlfile; DLModuleList *l; + int dlopen_flags; if ((dlfile = xf86loadercalloc(1, sizeof(DLModuleRec))) == NULL) { ErrorF("Unable to allocate DLModuleRec\n"); return NULL; } dlfile->handle = modrec->handle; - dlfile->dlhandle = dlopen(modrec->name, DLOPEN_FLAGS); + if (flags & LD_FLAG_GLOBAL) + dlopen_flags = DLOPEN_LAZY | DLOPEN_GLOBAL; + else + dlopen_flags = DLOPEN_LAZY; + dlfile->dlhandle = dlopen(modrec->name, dlopen_flags); if (dlfile->dlhandle == NULL) { ErrorF("dlopen: %s\n", dlerror()); xf86loaderfree(dlfile); return NULL; } - /* Add it to the module list */ + l = xf86loadermalloc(sizeof(DLModuleList)); l->module = dlfile; l->next = dlModuleList; diff --git a/hw/xfree86/loader/dlloader.h b/hw/xfree86/loader/dlloader.h index 1dfae274d..6475291b5 100644 --- a/hw/xfree86/loader/dlloader.h +++ b/hw/xfree86/loader/dlloader.h @@ -27,10 +27,11 @@ #ifndef _DLLOADER_H #define _DLLOADER_H -extern void *DLLoadModule(loaderPtr, int, LOOKUP **); +extern void *DLLoadModule(loaderPtr, int, LOOKUP **, int flags); extern void DLResolveSymbols(void *); extern int DLCheckForUnresolved(void *); extern void DLUnloadModule(void *); extern void *DLFindSymbol(const char *name); +extern void *DLFindSymbolLocal(pointer module, const char *name); #endif diff --git a/hw/xfree86/loader/elfloader.c b/hw/xfree86/loader/elfloader.c index 39772cf69..bcc6686f4 100644 --- a/hw/xfree86/loader/elfloader.c +++ b/hw/xfree86/loader/elfloader.c @@ -1,4 +1,4 @@ -/* $XdotOrg: xc/programs/Xserver/hw/xfree86/loader/elfloader.c,v 1.7 2005/04/23 19:01:13 ajax Exp $ */ +/* $XdotOrg: xserver/xorg/hw/xfree86/loader/elfloader.c,v 1.10.12.1 2006/02/24 05:49:34 krh Exp $ */ /* $XFree86: xc/programs/Xserver/hw/xfree86/loader/elfloader.c,v 1.61tsi Exp $ */ /* @@ -2884,7 +2884,7 @@ ELFCollectSections(ELFModulePtr elffile, int pass, int *totalsize, * Public API for the ELF implementation of the loader. */ void * -ELFLoadModule(loaderPtr modrec, int elffd, LOOKUP **ppLookup) +ELFLoadModule(loaderPtr modrec, int elffd, LOOKUP **ppLookup, int flags) { ELFModulePtr elffile; Elf_Ehdr *header; diff --git a/hw/xfree86/loader/elfloader.h b/hw/xfree86/loader/elfloader.h index 6e9f02ca4..8cb09eeba 100644 --- a/hw/xfree86/loader/elfloader.h +++ b/hw/xfree86/loader/elfloader.h @@ -30,7 +30,7 @@ #ifndef _ELFLOADER_H #define _ELFLOADER_H /* elfloader.c */ -extern void *ELFLoadModule(loaderPtr, int, LOOKUP **); +extern void *ELFLoadModule(loaderPtr, int, LOOKUP **, int flags); extern void ELFResolveSymbols(void *); extern int ELFCheckForUnresolved(void *); extern char *ELFAddressToSection(void *, unsigned long); diff --git a/hw/xfree86/loader/loader.c b/hw/xfree86/loader/loader.c index 5a2c127d5..315926b18 100644 --- a/hw/xfree86/loader/loader.c +++ b/hw/xfree86/loader/loader.c @@ -973,7 +973,7 @@ _LoaderHandleUnresolved(char *symbol, char *module) * Handle an archive. */ void * -ARCHIVELoadModule(loaderPtr modrec, int arfd, LOOKUP ** ppLookup) +ARCHIVELoadModule(loaderPtr modrec, int arfd, LOOKUP ** ppLookup, int flags) { loaderPtr tmp = NULL; void *ret = NULL; @@ -1171,7 +1171,7 @@ ARCHIVELoadModule(loaderPtr modrec, int arfd, LOOKUP ** ppLookup) } offsetbias = offset; - if ((tmp->private = funcs[modtype].LoadModule(tmp, arfd, &lookup_ret)) + if ((tmp->private = funcs[modtype].LoadModule(tmp, arfd, &lookup_ret, LD_FLAG_GLOBAL)) == NULL) { ErrorF("Failed to load %s\n", hdr.ar_name); offsetbias = 0; @@ -1233,13 +1233,14 @@ _LoaderGetRelocations(void *mod) return &(formatrec->pRelocs); } + /* * Public Interface to the loader. */ int LoaderOpen(const char *module, const char *cname, int handle, - int *errmaj, int *errmin, int *wasLoaded) + int *errmaj, int *errmin, int *wasLoaded, int flags) { loaderPtr tmp; int new_handle, modtype; @@ -1329,7 +1330,7 @@ LoaderOpen(const char *module, const char *cname, int handle, tmp->module = moduleseq++; tmp->funcs = &funcs[modtype]; - if ((tmp->private = funcs[modtype].LoadModule(tmp, fd, &pLookup)) == NULL) { + if ((tmp->private = funcs[modtype].LoadModule(tmp, fd, &pLookup, flags)) == NULL) { xf86Msg(X_ERROR, "Failed to load %s\n", module); _LoaderListPop(new_handle); freeHandles[new_handle] = HANDLE_FREE; diff --git a/hw/xfree86/loader/loader.h b/hw/xfree86/loader/loader.h index 307b9bb48..cc8b8f381 100644 --- a/hw/xfree86/loader/loader.h +++ b/hw/xfree86/loader/loader.h @@ -80,6 +80,11 @@ #define LD_PROCESSED_ARCHIVE -1 /* #define UNINIT_SECTION */ #define HANDLE_IN_HASH_ENTRY + +/* LoadModule proc flags; LD_FLAG_GLOBAL adds symbols to global + * namespace, default is to keep symbols local to module. */ +#define LD_FLAG_GLOBAL 1 + /* * COFF Section nmumbers */ @@ -193,7 +198,7 @@ typedef struct _loader *loaderPtr; * _loader_funcs hold the entry points for a module format. */ -typedef void *(*LoadModuleProcPtr) (loaderPtr modrec, int fd, LOOKUP **); +typedef void *(*LoadModuleProcPtr) (loaderPtr modrec, int fd, LOOKUP **, int flags); typedef void (*ResolveSymbolsProcPtr) (void *); typedef int (*CheckForUnresolvedProcPtr) (void *); typedef char *(*AddressToSectionProcPtr) (void *, unsigned long); @@ -256,7 +261,7 @@ void LoaderDumpSymbols(void); char *_LoaderModuleToName(int); int _LoaderAddressToSection(const unsigned long, const char **, const char **); -int LoaderOpen(const char *, const char *, int, int *, int *, int *); +int LoaderOpen(const char *, const char *, int, int *, int *, int *, int); int LoaderHandleOpen(int); /* @@ -285,7 +290,7 @@ char *_LoaderHandleToCanonicalName(int handle); #include "elfloader.h" #include "dlloader.h" /* LD_ARCHIVE */ -void *ARCHIVELoadModule(loaderPtr, int, LOOKUP **); +void *ARCHIVELoadModule(loaderPtr, int, LOOKUP **, int flags); extern void _loader_debug_state(void); diff --git a/hw/xfree86/loader/loaderProcs.h b/hw/xfree86/loader/loaderProcs.h index 72591a5df..19752abe3 100644 --- a/hw/xfree86/loader/loaderProcs.h +++ b/hw/xfree86/loader/loaderProcs.h @@ -92,6 +92,10 @@ ModuleDescPtr LoadModule(const char *, const char *, const char **, ModuleDescPtr LoadSubModule(ModuleDescPtr, const char *, const char **, const char **, pointer, const XF86ModReqInfo *, int *, int *); +ModuleDescPtr LoadSubModuleLocal(ModuleDescPtr, const char *, + const char **, const char **, + pointer, const XF86ModReqInfo *, + int *, int *); ModuleDescPtr DuplicateModule(ModuleDescPtr mod, ModuleDescPtr parent); void LoadFont(FontModule *); void UnloadModule(ModuleDescPtr); diff --git a/hw/xfree86/loader/loadmod.c b/hw/xfree86/loader/loadmod.c index 63b9b3d24..4316d424f 100644 --- a/hw/xfree86/loader/loadmod.c +++ b/hw/xfree86/loader/loadmod.c @@ -88,6 +88,10 @@ static Bool CheckVersion(const char *, XF86ModuleVersionInfo *, static void UnloadModuleOrDriver(ModuleDescPtr mod); static char *LoaderGetCanonicalName(const char *, PatternPtr); static void RemoveChild(ModuleDescPtr); +static ModuleDescPtr doLoadModule(const char *, const char *, const char **, + const char **, pointer, + const XF86ModReqInfo *, int *, int *, + int flags); ModuleVersions LoaderVersionInfo = { XORG_VERSION_CURRENT, @@ -782,8 +786,44 @@ LoadSubModule(ModuleDescPtr parent, const char *module, return NULL; } - submod = LoadModule(module, NULL, subdirlist, patternlist, options, - modreq, errmaj, errmin); + submod = doLoadModule(module, NULL, subdirlist, patternlist, options, + modreq, errmaj, errmin, LD_FLAG_GLOBAL); + if (submod) { + parent->child = AddSibling(parent->child, submod); + submod->parent = parent; + } + return submod; +} + +ModuleDescPtr +LoadSubModuleLocal(ModuleDescPtr parent, const char *module, + const char **subdirlist, const char **patternlist, + pointer options, const XF86ModReqInfo * modreq, + int *errmaj, int *errmin) +{ + ModuleDescPtr submod; + + xf86MsgVerb(X_INFO, 3, "Loading local sub module \"%s\"\n", module); + + /* Absolute module paths are not allowed here */ +#ifndef __UNIXOS2__ + if (module[0] == '/') +#else + if (isalpha(module[0]) && module[1] == ':' && module[2] == '/') +#endif + { + xf86Msg(X_ERROR, + "LoadSubModule: Absolute module path not permitted: \"%s\"\n", + module); + if (errmaj) + *errmaj = LDR_BADUSAGE; + if (errmin) + *errmin = 0; + return NULL; + } + + submod = doLoadModule(module, NULL, subdirlist, patternlist, options, + modreq, errmaj, errmin, 0); if (submod) { parent->child = AddSibling(parent->child, submod); submod->parent = parent; @@ -823,48 +863,12 @@ DuplicateModule(ModuleDescPtr mod, ModuleDescPtr parent) return ret; } -/* - * LoadModule: load a module - * - * module The module name. Normally this is not a filename but the - * module's "canonical name. A full pathname is, however, - * also accepted. - * path A comma separated list of module directories. - * subdirlist A NULL terminated list of subdirectories to search. When - * NULL, the default "stdSubdirs" list is used. The default - * list is also substituted for entries with value DEFAULT_LIST. - * patternlist A NULL terminated list of regular expressions used to find - * module filenames. Each regex should contain exactly one - * subexpression that corresponds to the canonical module name. - * When NULL, the default "stdPatterns" list is used. The - * default list is also substituted for entries with value - * DEFAULT_LIST. - * options A NULL terminated list of Options that are passed to the - * module's SetupProc function. - * modreq An optional XF86ModReqInfo* containing - * version/ABI/vendor-ABI requirements to check for when - * loading the module. The following fields of the - * XF86ModReqInfo struct are checked: - * majorversion - must match the module's majorversion exactly - * minorversion - the module's minorversion must be >= this - * patchlevel - the module's minorversion.patchlevel must be - * >= this. Patchlevel is ignored when - * minorversion is not set. - * abiclass - (string) must match the module's abiclass - * abiversion - must be consistent with the module's - * abiversion (major equal, minor no older) - * moduleclass - string must match the module's moduleclass - * string - * "don't care" values are ~0 for numbers, and NULL for strings - * errmaj Major error return. - * errmin Minor error return. - * - */ -ModuleDescPtr -LoadModule(const char *module, const char *path, const char **subdirlist, - const char **patternlist, pointer options, - const XF86ModReqInfo * modreq, int *errmaj, int *errmin) +static ModuleDescPtr +doLoadModule(const char *module, const char *path, const char **subdirlist, + const char **patternlist, pointer options, + const XF86ModReqInfo * modreq, + int *errmaj, int *errmin, int flags) { XF86ModuleData *initdata = NULL; char **pathlist = NULL; @@ -957,7 +961,8 @@ LoadModule(const char *module, const char *path, const char **subdirlist, *errmin = 0; goto LoadModule_fail; } - ret->handle = LoaderOpen(found, name, 0, errmaj, errmin, &wasLoaded); + ret->handle = LoaderOpen(found, name, 0, + errmaj, errmin, &wasLoaded, flags); if (ret->handle < 0) goto LoadModule_fail; @@ -1066,6 +1071,52 @@ LoadModule(const char *module, const char *path, const char **subdirlist, return ret; } +/* + * LoadModule: load a module + * + * module The module name. Normally this is not a filename but the + * module's "canonical name. A full pathname is, however, + * also accepted. + * path A comma separated list of module directories. + * subdirlist A NULL terminated list of subdirectories to search. When + * NULL, the default "stdSubdirs" list is used. The default + * list is also substituted for entries with value DEFAULT_LIST. + * patternlist A NULL terminated list of regular expressions used to find + * module filenames. Each regex should contain exactly one + * subexpression that corresponds to the canonical module name. + * When NULL, the default "stdPatterns" list is used. The + * default list is also substituted for entries with value + * DEFAULT_LIST. + * options A NULL terminated list of Options that are passed to the + * module's SetupProc function. + * modreq An optional XF86ModReqInfo* containing + * version/ABI/vendor-ABI requirements to check for when + * loading the module. The following fields of the + * XF86ModReqInfo struct are checked: + * majorversion - must match the module's majorversion exactly + * minorversion - the module's minorversion must be >= this + * patchlevel - the module's minorversion.patchlevel must be + * >= this. Patchlevel is ignored when + * minorversion is not set. + * abiclass - (string) must match the module's abiclass + * abiversion - must be consistent with the module's + * abiversion (major equal, minor no older) + * moduleclass - string must match the module's moduleclass + * string + * "don't care" values are ~0 for numbers, and NULL for strings + * errmaj Major error return. + * errmin Minor error return. + * + */ +ModuleDescPtr +LoadModule(const char *module, const char *path, const char **subdirlist, + const char **patternlist, pointer options, + const XF86ModReqInfo * modreq, int *errmaj, int *errmin) +{ + return doLoadModule(module, path, subdirlist, patternlist, options, + modreq, errmaj, errmin, LD_FLAG_GLOBAL); +} + ModuleDescPtr LoadDriver(const char *module, const char *path, int handle, pointer options, int *errmaj, int *errmin) diff --git a/include/dix-config.h.in b/include/dix-config.h.in index 0e3f8f985..f33e5827f 100644 --- a/include/dix-config.h.in +++ b/include/dix-config.h.in @@ -53,6 +53,12 @@ /* Build GLX extension */ #undef GLXEXT +/* Build GLX DRI loader */ +#undef GLX_DRI + +/* Path to DRI drivers */ +#undef DRI_DRIVER_PATH + /* Include handhelds.org h3600 touchscreen driver */ #undef H3600_TS diff --git a/mi/miinitext.c b/mi/miinitext.c index 5d7b0b079..7939a5f21 100644 --- a/mi/miinitext.c +++ b/mi/miinitext.c @@ -1,4 +1,4 @@ -/* $XdotOrg: xserver/xorg/mi/miinitext.c,v 1.30 2006/01/08 23:43:54 ajax Exp $ */ +/* $XdotOrg: xserver/xorg/mi/miinitext.c,v 1.31 2006/02/15 19:05:54 ajax Exp $ */ /* $XFree86: xc/programs/Xserver/mi/miinitext.c,v 3.67 2003/01/12 02:44:27 dawes Exp $ */ /*********************************************************** @@ -350,6 +350,9 @@ extern void XFree86MiscExtensionInit(INITARGS); extern void XFree86DGAExtensionInit(INITARGS); #endif #ifdef GLXEXT +typedef struct __GLXprovider __GLXprovider; +extern __GLXprovider __glXMesaProvider; +extern void GlxPushProvider(__GLXprovider *impl); #ifndef __DARWIN__ extern void GlxExtensionInit(INITARGS); extern void GlxWrapInitVisuals(miInitVisualsProcPtr *); @@ -643,6 +646,8 @@ InitExtensions(argc, argv) #endif #endif #ifdef GLXEXT + + GlxPushProvider(&__glXMesaProvider); #ifndef __DARWIN__ if (!noGlxExtension) GlxExtensionInit(); #else |