Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:dreveman:Factory:cr
Mesa
project.diff
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File project.diff of Package Mesa
--- Mesa.changes.orig +++ Mesa.changes @@ -1,4 +1,10 @@ ------------------------------------------------------------------- +Thu Mar 12 14:34:53 EDT 2009 - davidr@novell.com + +- Chromium DRI support. +- Avoid non 32-bit ARGB visuals when LIBGL_ONLY_ARGB_VISUALS is set. + +------------------------------------------------------------------- Sat Mar 7 04:17:18 CET 2009 - sndirsch@suse.de - mesa-commit-954dfba.diff --- Mesa.spec.orig +++ Mesa.spec @@ -19,7 +19,7 @@ Name: Mesa -BuildRequires: gcc-c++ libdrm-devel libexpat-devel pkgconfig xorg-x11-devel +BuildRequires: gcc-c++ libdrm-devel libexpat-devel pkgconfig xorg-x11-devel cr-devel Url: http://www.mesa3d.org License: X11/MIT Group: System/Libraries @@ -47,6 +47,8 @@ Patch9: mesa-commit-954dfba.diff Patch10: mesa-commit-88b702e.diff Patch14: intel_release_static_region.patch Patch15: Mesa_indirect_old_xserver_compatibility.diff +Patch16: mesa-chromium.diff +Patch17: mesa-only-argb-visuals.diff BuildRoot: %{_tmppath}/%{name}-%{version}-build %description @@ -141,11 +143,13 @@ sed -i 's/REPLACE/%_lib/g' src/glx/x11/M %patch10 -p1 %patch14 -p1 %patch15 -p1 +%patch16 -p1 +%patch17 -p1 %build %install -#autoreconf -fi +autoreconf -fi ### libGL (disable savage/mga, bnc #402132/#403071) %configure --disable-glw \ --with-driver=dri \ @@ -155,7 +159,8 @@ sed -i 's/REPLACE/%_lib/g' src/glx/x11/M %ifarch s390 s390x --with-dri-drivers=swrast \ %endif - --disable-glut + --disable-glut \ + --enable-chromium gmake make install DESTDIR=$RPM_BUILD_ROOT # build and install Indirect Rendering only libGL --- mesa-chromium.diff.orig +++ mesa-chromium.diff @@ -0,0 +1,774 @@ +commit 664865d747b47409b04f13fbeb8402400e1e2046 +Author: David Reveman <davidr@novell.com> +Date: Wed Mar 11 13:36:53 2009 -0400 + + Chromium DRI support. + +diff --git a/configure.ac b/configure.ac +index 46070fd..87b1e8c 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -1180,6 +1180,20 @@ if test "x$enable_gallium_nouveau" = xyes; then + GALLIUM_DRIVERS_DIRS="$GALLIUM_DRIVERS_DIRS nv04 nv10 nv20 nv30 nv40 nv50" + fi + ++dnl CHROMIUM ++AC_ARG_ENABLE([chromium], ++ [AS_HELP_STRING([--enable-chromium], ++ [use CHROMIUM for GLX @<:@default=disabled@:>@])], ++ [enable_cr="$enableval"], ++ [enable_cr=no]) ++if test "x$enable_cr" = xyes; then ++ PKG_CHECK_MODULES([CHROMIUM], [cr]) ++ X11_INCLUDES="$X11_INCLUDES $CHROMIUM_CFLAGS" ++ GL_LIB_DEPS="$GL_LIB_DEPS $CHROMIUM_LIBS" ++ DEFINES="$DEFINES -DCHROMIUM" ++else ++ enable_cr=no ++fi + + dnl Restore LDFLAGS and CPPFLAGS + LDFLAGS="$_SAVE_LDFLAGS" +@@ -1226,6 +1240,7 @@ fi + echo " DRI driver dir: $DRI_DRIVER_INSTALL_DIR" + fi + echo " Use XCB: $enable_xcb" ++echo " Use CHROMIUM: $enable_cr" + + echo "" + if echo "$SRC_DIRS" | grep 'gallium' >/dev/null 2>&1; then +diff --git a/src/glx/x11/Makefile b/src/glx/x11/Makefile +index 86d84d4..f81a5c7 100644 +--- a/src/glx/x11/Makefile ++++ b/src/glx/x11/Makefile +@@ -32,6 +32,7 @@ SOURCES = \ + glx_pbuffer.c \ + glx_query.c \ + drisw_glx.c \ ++ dricr_glx.c \ + dri_common.c \ + dri_glx.c \ + XF86dri.c \ +diff --git a/src/glx/x11/dricr_glx.c b/src/glx/x11/dricr_glx.c +new file mode 100644 +index 0000000..6211cd1 +--- /dev/null ++++ b/src/glx/x11/dricr_glx.c +@@ -0,0 +1,653 @@ ++/* ++ * Copyright © 2009 Novell, 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 ++ * Novell, Inc. not be used in advertising or publicity pertaining to ++ * distribution of the software without specific, written prior permission. ++ * Novell, Inc. makes no representations about the suitability of this ++ * software for any purpose. It is provided "as is" without express or ++ * implied warranty. ++ * ++ * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, ++ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN ++ * NO EVENT SHALL NOVELL, 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. ++ * ++ * Author: David Reveman <davidr@novell.com> ++ */ ++ ++#ifdef GLX_DIRECT_RENDERING ++#ifdef CHROMIUM ++ ++#include <stdarg.h> ++#include <X11/Xlib.h> ++#include <X11/Xatom.h> ++#include "glxclient.h" ++#include "glcontextmodes.h" ++#include "dri_common.h" ++#include "cr_spu.h" ++#include "cr_net.h" ++#include "cr_error.h" ++#include "cr_mem.h" ++#include "cr_string.h" ++#include "cr_mothership.h" ++#include "cr_net.h" ++#include "cr_environment.h" ++#include "cr_process.h" ++ ++#include "glapi.h" ++#include "glapioffsets.h" ++#include "glapitable.h" ++ ++#define KEYWORD1 static ++#define KEYWORD1_ALT static ++#define KEYWORD2 GLAPIENTRY ++#define NAME(func) NoOp##func ++ ++#define F NULL ++ ++#define DISPATCH(func, args, msg) \ ++ crErrorMessage (F, "unimplemented GL dispatch function call: "); \ ++ crErrorMessage msg ++ ++#define RETURN_DISPATCH(func, args, msg) \ ++ crErrorMessage (F, "unimplemented GL dispatch function call: "); \ ++ crErrorMessage msg; \ ++ return 0 ++ ++#define DISPATCH_TABLE_NAME __glapi_table ++#define UNUSED_TABLE_NAME __unused_functions ++ ++#define TABLE_ENTRY(name) (_glapi_proc) NoOp##name ++ ++static void crErrorMessage (void *d, const char *f, ...) ++{ ++ va_list args; ++ const char *env; ++ ++ if ((env = getenv ("LIBGL_DEBUG")) && !strstr (env, "quiet")) ++ { ++ fprintf (stderr, "libGL error: "); ++ va_start (args, f); ++ vfprintf (stderr, f, args); ++ va_end (args); ++ } ++} ++ ++static GLint NoOpUnused (void) ++{ ++ crErrorMessage (F, "unused GL dispatch function call\n"); ++ return 0; ++} ++ ++#include "glapitemp.h" ++ ++typedef struct __GLXDRIdisplayPrivateRec __GLXDRIdisplayPrivate; ++typedef struct __GLXDRIscreenPrivateRec __GLXDRIscreenPrivate; ++typedef struct __GLXDRIcontextPrivateRec __GLXDRIcontextPrivate; ++typedef struct __GLXDRIdrawablePrivateRec __GLXDRIdrawablePrivate; ++ ++struct __GLXDRIdisplayPrivateRec ++{ ++ __GLXDRIdisplay base; ++ SPU *spu; ++}; ++ ++struct __GLXDRIscreenPrivateRec ++{ ++ __GLXDRIscreen base; ++ struct __GLXDRIdisplayPrivateRec *pdp; ++}; ++ ++struct __GLXDRIcontextPrivateRec ++{ ++ __GLXDRIcontext base; ++ __GLXscreenConfigs *psc; ++ GLint spuContext; ++}; ++ ++struct __GLXDRIdrawablePrivateRec ++{ ++ __GLXDRIdrawable base; ++ GLint spuDrawable; ++}; ++ ++static void ++driGetConfigurationOptions (CRConnection *conn, ++ char **spuDir) ++{ ++ char response[1024]; ++ int myRank = 0; ++ int lowContext = CR_QUADRICS_DEFAULT_LOW_CONTEXT; ++ int highContext = CR_QUADRICS_DEFAULT_HIGH_CONTEXT; ++ char *lowNode = "none"; ++ char *highNode = "none"; ++ unsigned char key[16]= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; ++ ++ if (crMothershipGetFakerParam (conn, response, "spu_dir") && ++ crStrlen (response) > 0) ++ { ++ *spuDir = crStrdup (response); ++ } ++ else ++ { ++ *spuDir = NULL; ++ } ++ ++ if (crMothershipGetRank (conn, response)) ++ myRank = crStrToInt (response); ++ ++ crNetSetRank (myRank); ++ ++ if (crMothershipGetParam (conn, "low_context", response)) ++ lowContext = crStrToInt (response); ++ if (crMothershipGetParam (conn, "high_context", response)) ++ highContext = crStrToInt (response); ++ ++ crNetSetContextRange (lowContext, highContext); ++ ++ if (crMothershipGetParam (conn, "low_node", response)) ++ lowNode = crStrdup (response); ++ if (crMothershipGetParam (conn, "high_node", response)) ++ highNode = crStrdup (response); ++ ++ crNetSetNodeRange (lowNode, highNode); ++ ++ if (crMothershipGetParam (conn, "comm_key", response)) ++ { ++ unsigned int a; ++ char **words, *found; ++ ++ /* remove the silly []'s */ ++ while ((found = crStrchr (response, '[')) != NULL) ++ *found = ' '; ++ while ((found = crStrchr (response, ']')) != NULL) ++ *found = ' '; ++ ++ words = crStrSplit(response, ","); ++ ++ a = 0; ++ while (words[a] != NULL && a < sizeof (key)) ++ { ++ key[a]= crStrToInt (words[a]); ++ a++; ++ } ++ ++ crFreeStrings (words); ++ } ++ ++ crNetSetKey (key, sizeof (key)); ++} ++ ++static const void * ++__cr_lookup_func (const char *name, SPU *spu) ++{ ++ SPUNamedFunctionTable *temp; ++ ++ if (spu == NULL) ++ return NULL; ++ ++ for (temp = spu->function_table->table; temp->name != NULL; temp++) ++ if (!strcmp (name, temp->name)) ++ return temp->fn; ++ ++ return __cr_lookup_func (name, spu->superSPU); ++} ++ ++static const void * ++__cr_fuzzy_lookup_func (const char *name, SPU *spu) ++{ ++ SPUNamedFunctionTable *temp; ++ ++ if (spu == NULL) ++ return NULL; ++ ++ for (temp = spu->function_table->table; temp->name != NULL; temp++) ++ { ++ static const char *suffix[] = { ++ "EXT", "ARB", "NV", "ATI", "SGIS", "MESA", "IBM", "APPLE" ++ }; ++ int i, j; ++ ++ for (i = 0; temp->name[i] == name[i]; i++) ++ if (name[i] == '\0') ++ return temp->fn; ++ ++ j = 0; ++ if (name[i] != '\0') ++ for (; j < sizeof (suffix) / sizeof (suffix[0]); j++) ++ if (strcmp (&name[i], suffix[j]) == 0) ++ break; ++ ++ if (j < sizeof (suffix) / sizeof (suffix[0])) ++ { ++ if (temp->name[i] == '\0') ++ return temp->fn; ++ ++ for (j = 0; j < sizeof (suffix) / sizeof (suffix[0]); j++) ++ if (strcmp (&temp->name[i], suffix[j]) == 0) ++ return temp->fn; ++ } ++ } ++ ++ return __cr_fuzzy_lookup_func (name, spu->superSPU); ++} ++ ++static const void * ++__cr_reverse_lookup_func (int offset, SPU *spu) ++{ ++ SPUNamedFunctionTable *temp; ++ char name[1024]; ++ ++ if (spu == NULL) ++ return NULL; ++ ++ name[0] = 'g'; ++ name[1] = 'l'; ++ ++ for (temp = spu->function_table->table; temp->name != NULL; temp++) ++ { ++ strcpy (&name[2], temp->name); ++ ++ if (_glapi_get_proc_offset (name) == offset) ++ return temp->fn; ++ } ++ ++ return __cr_reverse_lookup_func (offset, spu->superSPU); ++} ++ ++static SPU * ++driCreateSPUChain (Display *dpy) ++{ ++ CRConnection *conn; ++ char response[1024]; ++ char *spuDir = NULL; ++ char **spuChain; ++ int numSpus; ++ int *spuIds; ++ char **spuNames; ++ SPU *spu = NULL; ++ int i; ++ char *env; ++ Atom actual; ++ int result, format; ++ unsigned long n, left; ++ unsigned char *data = NULL; ++ static Display *display = 0; ++ ++ if (display) ++ return NULL; ++ ++ display = dpy; ++ ++ env = getenv ("CRMOTHERSHIP"); ++ if (env) ++ env = strdup (env); ++ ++ result = XGetWindowProperty (dpy, DefaultRootWindow (dpy), ++ XInternAtom (dpy, "CRMOTHERSHIP", False), ++ 0L, 1024L, False, ++ XA_STRING, ++ &actual, &format, ++ &n, &left, &data); ++ ++ if (result == Success && n && data) ++ { ++ char str[1025]; ++ ++ strncpy (str, (const char *) data, n); ++ str[n] = '\0'; ++ ++ InfoMessageF ("Found CRMOTHERSHIP property on root window\n"); ++ setenv ("CRMOTHERSHIP", str, 1); ++ } ++ else if (env) ++ { ++ InfoMessageF ("Found CRMOTHERSHIP environment variable\n"); ++ } ++ else ++ { ++ return NULL; ++ } ++ ++ InfoMessageF ("Connecting to CHROMIUM mothership: %s\n", ++ getenv ("CRMOTHERSHIP")); ++ ++ conn = crMothershipConnect (); ++ if (conn) ++ { ++ char *appId = getenv ("CR_APPLICATION_ID_NUMBER"); ++ ++ if (!appId) ++ appId = "-1"; ++ ++ InfoMessageF ("Using CHROMIUM application ID: %s\n", appId); ++ ++ crMothershipIdentifyOpenGL (conn, response, appId); ++ ++ spuChain = crStrSplit (response, " "); ++ numSpus = crStrToInt (spuChain[0]); ++ spuIds = (int *) crAlloc (numSpus * sizeof (*spuIds)); ++ spuNames = (char **) crAlloc (numSpus * sizeof (*spuNames)); ++ ++ for (i = 0; i < numSpus; i++) ++ { ++ spuIds[i] = crStrToInt (spuChain[2 * i + 1]); ++ spuNames[i] = crStrdup (spuChain[2 * i + 2]); ++ } ++ ++ driGetConfigurationOptions (conn, &spuDir); ++ ++ crMothershipDisconnect (conn); ++ ++ if (spuDir) ++ InfoMessageF ("Using CHROMIUM SPU directory: %s\n", spuDir); ++ ++ InfoMessageF ("Loading CHROMIUM SPU chain:\n"); ++ ++ for (i = 0; i < numSpus; i++) ++ InfoMessageF (" SPU %d/%d: (%d) \"%s\"\n", ++ i + 1, numSpus, spuIds[i], spuNames[i]); ++ ++ spu = crSPULoadChain (numSpus, spuIds, spuNames, spuDir, NULL); ++ ++ crFree (spuChain); ++ crFree (spuIds); ++ for (i = 0; i < numSpus; i++) ++ crFree (spuNames[i]); ++ crFree (spuNames); ++ ++ if (spuDir) ++ crFree (spuDir); ++ ++ if (spu) ++ { ++ const int entries = sizeof (__glapi_table) / sizeof (void *); ++ const void **tab = (const void **) __glapi_table; ++ int i, count = 0, missing = 0; ++ ++ for (i = 0; i < entries; i++) ++ { ++ const char *name = _glapi_get_proc_name (i); ++ ++ if (name && name[0] == 'g' && name[1] == 'l') ++ { ++ const void *proc; ++ ++ count++; ++ ++ proc = __cr_lookup_func (&name[2], spu); ++ if (proc) ++ { ++ tab[i] = proc; ++ continue; ++ } ++ ++ proc = __cr_reverse_lookup_func (i, spu); ++ if (proc) ++ { ++ tab[i] = proc; ++ continue; ++ } ++ ++ proc = __cr_fuzzy_lookup_func (&name[2], spu); ++ if (proc) ++ { ++ tab[i] = proc; ++ continue; ++ } ++ ++ missing++; ++ } ++ } ++ ++ InfoMessageF ("CHROMIUM dispatch table completeness: " ++ "%d/%d (%d missing)\n", ++ count - missing, count, missing); ++ ++ _glapi_set_dispatch ((struct _glapi_table *) __glapi_table); ++ } ++ } ++ else ++ { ++ ErrorMessageF ("Unable to connect to CHROMIUM mothership"); ++ } ++ ++ if (env) ++ { ++ setenv ("CRMOTHERSHIP", env, 1); ++ free (env); ++ } ++ ++ if (data) ++ XFree (data); ++ ++ return spu; ++} ++ ++static GLint ++visBitsFromMode (const __GLcontextModes *mode) ++{ ++ GLint visBits = 0; ++ ++ if (mode->rgbMode) ++ visBits |= CR_RGB_BIT; ++ ++ if (mode->doubleBufferMode) ++ visBits |= CR_DOUBLE_BIT; ++ ++ if (mode->haveDepthBuffer) ++ visBits |= CR_DEPTH_BIT; ++ ++ if (mode->haveStencilBuffer) ++ visBits |= CR_STENCIL_BIT; ++ ++ return visBits; ++} ++ ++static void ++driDestroyContext (__GLXDRIcontext *context, ++ __GLXscreenConfigs *psc, ++ Display *dpy) ++{ ++ __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context; ++ __GLXDRIscreenPrivate *psp = (__GLXDRIscreenPrivate *) ++ pcp->psc->driScreen; ++ ++ (*psp->pdp->spu->dispatch_table.DestroyContext) (pcp->spuContext); ++ ++ Xfree (pcp); ++} ++ ++static Bool ++driBindContext (__GLXDRIcontext *context, ++ __GLXDRIdrawable *draw, ++ __GLXDRIdrawable *read) ++{ ++ __GLXDRIcontextPrivate *pcp = (__GLXDRIcontextPrivate *) context; ++ __GLXDRIdrawablePrivate *pdp = (__GLXDRIdrawablePrivate *) draw; ++ __GLXDRIscreenPrivate *psp = (__GLXDRIscreenPrivate *) ++ pcp->psc->driScreen; ++ ++ if (draw != read) ++ return False; ++ ++ (*psp->pdp->spu->dispatch_table.MakeCurrent) (pdp->spuDrawable, ++ draw->xDrawable, ++ pcp->spuContext); ++ ++ return True; ++} ++ ++static void ++driUnbindContext (__GLXDRIcontext *context) ++{ ++} ++ ++static __GLXDRIcontext * ++driCreateContext (__GLXscreenConfigs *psc, ++ const __GLcontextModes *mode, ++ GLXContext gc, ++ GLXContext shareList, ++ int renderType) ++{ ++ __GLXDRIcontextPrivate *pcp, *pcp_shared; ++ __GLXDRIscreenPrivate *psp = (__GLXDRIscreenPrivate *) psc->driScreen; ++ GLint spuShareContext = 0; ++ ++ if (!psc || !psp) ++ return NULL; ++ ++ if (shareList) ++ { ++ pcp_shared = (__GLXDRIcontextPrivate *) shareList->driContext; ++ spuShareContext = pcp_shared->spuContext; ++ } ++ ++ pcp = Xmalloc (sizeof *pcp); ++ if (pcp == NULL) ++ return NULL; ++ ++ pcp->base.destroyContext = driDestroyContext; ++ pcp->base.bindContext = driBindContext; ++ pcp->base.unbindContext = driUnbindContext; ++ ++ pcp->psc = psc; ++ pcp->spuContext = ++ (*psp->pdp->spu->dispatch_table.CreateContext) (DisplayString (psc->dpy), ++ visBitsFromMode (mode), ++ spuShareContext); ++ if (pcp->spuContext == -1) ++ { ++ Xfree (pcp); ++ return NULL; ++ } ++ ++ return &pcp->base; ++} ++ ++static void ++driDestroyDrawable (__GLXDRIdrawable *pdraw) ++{ ++ __GLXDRIdrawablePrivate *pdp = (__GLXDRIdrawablePrivate *) pdraw; ++ __GLXDRIscreenPrivate *psp = (__GLXDRIscreenPrivate *) ++ pdraw->psc->driScreen; ++ ++ (*psp->pdp->spu->dispatch_table.WindowDestroy) (pdp->spuDrawable); ++ ++ Xfree (pdp); ++} ++ ++static __GLXDRIdrawable * ++driCreateDrawable (__GLXscreenConfigs *psc, ++ XID xDrawable, ++ GLXDrawable drawable, ++ const __GLcontextModes *mode) ++{ ++ __GLXDRIdrawablePrivate *pdp; ++ __GLXDRIscreenPrivate *psp = (__GLXDRIscreenPrivate *) psc->driScreen; ++ ++ pdp = Xmalloc (sizeof *pdp); ++ if (!pdp) ++ return NULL; ++ ++ pdp->base.destroyDrawable = driDestroyDrawable; ++ pdp->base.xDrawable = xDrawable; ++ pdp->base.drawable = drawable; ++ pdp->base.psc = psc; ++ pdp->base.textureTarget = 0; ++ pdp->base.driDrawable = NULL; ++ ++ XSync (psc->dpy, False); ++ ++ pdp->spuDrawable = ++ (*psp->pdp->spu->dispatch_table.WindowCreate) (DisplayString (psc->dpy), ++ visBitsFromMode (mode)); ++ if (pdp->spuDrawable == -1) ++ { ++ Xfree (pdp); ++ return NULL; ++ } ++ ++ return &pdp->base; ++} ++ ++static void ++driSwapBuffers (__GLXDRIdrawable *pdraw) ++{ ++ __GLXDRIdrawablePrivate *pdp = (__GLXDRIdrawablePrivate *) pdraw; ++ __GLXDRIscreenPrivate *psp = (__GLXDRIscreenPrivate *) ++ pdraw->psc->driScreen; ++ ++ (*psp->pdp->spu->dispatch_table.SwapBuffers) (pdp->spuDrawable, 0); ++} ++ ++static void ++driDestroyScreen (__GLXscreenConfigs *psc) ++{ ++} ++ ++static __GLXDRIscreen * ++driCreateScreen (__GLXscreenConfigs *psc, ++ int screen, ++ __GLXdisplayPrivate *pd) ++{ ++ __GLXDRIdisplayPrivate *pdp = (__GLXDRIdisplayPrivate *) pd->dricrDisplay; ++ __GLXDRIscreenPrivate *psp; ++ ++ psp = Xmalloc (sizeof *psp); ++ if (psp == NULL) ++ return NULL; ++ ++ /* Initialize per screen dynamic client GLX extensions */ ++ psc->ext_list_first_time = GL_TRUE; ++ ++ psp->base.destroyScreen = driDestroyScreen; ++ psp->base.createContext = driCreateContext; ++ psp->base.createDrawable = driCreateDrawable; ++ psp->base.swapBuffers = driSwapBuffers; ++ ++ psp->pdp = pdp; ++ ++ return &psp->base; ++} ++ ++static void ++driDestroyDisplay (__GLXDRIdisplay *pd) ++{ ++ Xfree (pd); ++} ++ ++_X_HIDDEN __GLXDRIdisplay * ++dricrCreateDisplay (Display *dpy) ++{ ++ __GLXDRIdisplayPrivate *pdp; ++ ++ pdp = Xmalloc (sizeof *pdp); ++ if (pdp == NULL) ++ return NULL; ++ ++ pdp->spu = driCreateSPUChain (dpy); ++ if (pdp->spu == NULL) ++ { ++ Xfree (pdp); ++ return NULL; ++ } ++ ++ pdp->base.destroyDisplay = driDestroyDisplay; ++ pdp->base.createScreen = driCreateScreen; ++ ++ (void) __unused_functions; ++ ++ return &pdp->base; ++} ++ ++#endif /* CHROMIUM */ ++#endif /* GLX_DIRECT_RENDERING */ +diff --git a/src/glx/x11/glxclient.h b/src/glx/x11/glxclient.h +index caf58bb..18e032f 100644 +--- a/src/glx/x11/glxclient.h ++++ b/src/glx/x11/glxclient.h +@@ -170,6 +170,9 @@ struct __GLXDRIdrawableRec { + extern __GLXDRIdisplay *driswCreateDisplay(Display *dpy); + extern __GLXDRIdisplay *driCreateDisplay(Display *dpy); + extern __GLXDRIdisplay *dri2CreateDisplay(Display *dpy); ++#ifdef CHROMIUM ++extern __GLXDRIdisplay *dricrCreateDisplay(Display *dpy); ++#endif + + extern void DRI_glXUseXFont( Font font, int first, int count, int listbase ); + +@@ -594,6 +597,9 @@ struct __GLXdisplayPrivateRec { + __GLXDRIdisplay *driswDisplay; + __GLXDRIdisplay *driDisplay; + __GLXDRIdisplay *dri2Display; ++#ifdef CHROMIUM ++ __GLXDRIdisplay *dricrDisplay; ++#endif + #endif + }; + +diff --git a/src/glx/x11/glxext.c b/src/glx/x11/glxext.c +index b296b7c..af7de7c 100644 +--- a/src/glx/x11/glxext.c ++++ b/src/glx/x11/glxext.c +@@ -183,6 +183,12 @@ __glXFreeDisplayPrivate(XExtData * extension) + + #ifdef GLX_DIRECT_RENDERING + /* Free the direct rendering per display data */ ++#ifdef CHROMIUM ++ if (priv->dricrDisplay) ++ (*priv->dricrDisplay->destroyDisplay) (priv->dricrDisplay); ++ priv->dricrDisplay = NULL; ++#endif ++ + if (priv->driswDisplay) + (*priv->driswDisplay->destroyDisplay) (priv->driswDisplay); + priv->driswDisplay = NULL; +@@ -618,6 +624,11 @@ AllocAndFetchScreenConfigs(Display * dpy, __GLXdisplayPrivate * priv) + if (psc->driScreen == NULL && priv->driDisplay) + psc->driScreen = (*priv->driDisplay->createScreen) (psc, i, priv); + ++#ifdef CHROMIUM ++ if (psc->driScreen == NULL && priv->dricrDisplay) ++ psc->driScreen = (*priv->dricrDisplay->createScreen) (psc, i, priv); ++#endif ++ + if (psc->driScreen == NULL && priv->driswDisplay) + psc->driScreen = (*priv->driswDisplay->createScreen) (psc, i, priv); + +@@ -719,6 +730,10 @@ __glXInitialize(Display * dpy) + ** Note: This _must_ be done before calling any other DRI routines + ** (e.g., those called in AllocAndFetchScreenConfigs). + */ ++#ifdef CHROMIUM ++ if (glx_direct) ++ dpyPriv->dricrDisplay = dricrCreateDisplay(dpy); ++#endif + if (glx_direct && glx_accel) { + dpyPriv->dri2Display = dri2CreateDisplay(dpy); + dpyPriv->driDisplay = driCreateDisplay(dpy); --- mesa-only-argb-visuals.diff.orig +++ mesa-only-argb-visuals.diff @@ -0,0 +1,61 @@ +commit ebd2fd61610ba8df669f1e6638d1ca5f5422b22c +Author: David Reveman <davidr@novell.com> +Date: Thu Mar 12 14:13:08 2009 -0400 + + Avoid non 32-bit ARGB visuals when LIBGL_ONLY_ARGB_VISUALS is set. + +diff --git a/src/glx/x11/glxext.c b/src/glx/x11/glxext.c +index af7de7c..283a2b8 100644 +--- a/src/glx/x11/glxext.c ++++ b/src/glx/x11/glxext.c +@@ -504,6 +504,32 @@ createConfigsFromProperties(Display * dpy, int nvisuals, int nprops, + return modes; + } + ++static __GLcontextModes * ++disableNonArgbVisuals (Display * dpy, int screen, __GLcontextModes *modes) ++{ ++ __GLcontextModes *m; ++ ++ for (m = modes; m != NULL; m = m->next) { ++ XVisualInfo *vi, tmpl; ++ int i; ++ ++ tmpl.screen = screen; ++ tmpl.visualid = m->visualID; ++ vi = XGetVisualInfo( dpy, VisualScreenMask | VisualIDMask, &tmpl, &i ); ++ if (vi) { ++ if (vi->depth != 32) { ++ m->visualID = GLX_DONT_CARE; ++ m->fbconfigID = GLX_DONT_CARE; ++ m->drawableType = 0; ++ m->renderType = 0; ++ } ++ XFree (vi); ++ } ++ } ++ ++ return modes; ++} ++ + static GLboolean + getVisualConfigs(Display * dpy, __GLXdisplayPrivate * priv, int screen) + { +@@ -530,6 +556,8 @@ getVisualConfigs(Display * dpy, __GLXdisplayPrivate * priv, int screen) + + out: + UnlockDisplay(dpy); ++ if ((getenv("LIBGL_ONLY_ARGB_VISUALS") != NULL)) ++ psc->visuals = disableNonArgbVisuals (dpy, screen, psc->visuals); + return psc->visuals != NULL; + } + +@@ -577,6 +605,8 @@ getFBConfigs(Display * dpy, __GLXdisplayPrivate * priv, int screen) + + out: + UnlockDisplay(dpy); ++ if ((getenv("LIBGL_ONLY_ARGB_VISUALS") != NULL)) ++ psc->visuals = disableNonArgbVisuals (dpy, screen, psc->visuals); + return psc->configs != NULL; + } +
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor